From 2f81ba57d671fc74b94396b095c9c87ed2f71ee0 Mon Sep 17 00:00:00 2001 From: Paul Carduner Date: Sun, 20 Mar 2016 12:47:00 -0700 Subject: [PATCH 1/2] feat(formlyConfigProvider): Expose field types map from formlyConfigProvider For a plugin I am writing that renders an inspector showing the current configuration for formly, I need access to the types that have been registered with formly. This change exposes the map of type name to type configuration object via a new method on formlyConfigProvider called getTypes(). This is in support of issue #663 --- src/providers/formlyConfig.js | 5 +++++ src/providers/formlyConfig.test.js | 13 +++++++++++-- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/src/providers/formlyConfig.js b/src/providers/formlyConfig.js index 60398d52..49d357cc 100644 --- a/src/providers/formlyConfig.js +++ b/src/providers/formlyConfig.js @@ -15,6 +15,7 @@ function formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, angular.extend(this, { setType, getType, + getTypes, getTypeHeritage, setWrapper, getWrapper, @@ -161,6 +162,10 @@ function formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, } } + function getTypes() { + return typeMap + } + function getTypeHeritage(parent) { const heritage = [] let type = parent diff --git a/src/providers/formlyConfig.test.js b/src/providers/formlyConfig.test.js index 6d68edfd..11414ce8 100644 --- a/src/providers/formlyConfig.test.js +++ b/src/providers/formlyConfig.test.js @@ -185,8 +185,8 @@ describe('formlyConfig', () => { }) - describe('setType/getType', () => { - let getterFn, setterFn + describe('setType/getType/getTypes', () => { + let getterFn, setterFn, getTypesFn const name = 'input' const template = '' const templateUrl = '/input.html' @@ -195,6 +195,7 @@ describe('formlyConfig', () => { beforeEach(inject(function(formlyConfig) { getterFn = formlyConfig.getType setterFn = formlyConfig.setType + getTypesFn = formlyConfig.getTypes })) describe('＼(＾O＾)／ path', () => { @@ -217,6 +218,14 @@ describe('formlyConfig', () => { expect(getterFn('type2').templateUrl).to.equal(templateUrl) }) + it('should expose the mapping from type name to config', () => { + setterFn([ + {name, template}, + {name: 'type2', templateUrl}, + ]) + expect(getTypesFn()).to.eql({[name]: getterFn(name), type2: getterFn('type2')}) + }) + it('should allow you to set a wrapper as a string', () => { setterFn({name, template, wrapper}) expect(getterFn(name).wrapper).to.equal(wrapper) From 9ab5f32a88b2850c64b14af494f8a6cb74ef75dd Mon Sep 17 00:00:00 2001 From: formly-bot Date: Mon, 21 Mar 2016 17:29:37 +0000 Subject: [PATCH 2/2] v8.1.0 --- dist/formly.js | 2776 ++++++++++++++++++++++++++++++++++++++++ dist/formly.min.js | 4 + dist/formly.min.js.map | 1 + package.json | 4 +- 4 files changed, 2783 insertions(+), 2 deletions(-) create mode 100644 dist/formly.js create mode 100644 dist/formly.min.js create mode 100644 dist/formly.min.js.map diff --git a/dist/formly.js b/dist/formly.js new file mode 100644 index 00000000..52a85595 --- /dev/null +++ b/dist/formly.js @@ -0,0 +1,2776 @@ +/*! +* angular-formly JavaScript Library v8.1.0 +* +* @license MIT (http://license.angular-formly.com) +* +* built with ♥ by Astrism , Kent C. Dodds +* (ó ì_í)=óò=(ì_í ò) +*/ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("angular"), require("api-check")); + else if(typeof define === 'function' && define.amd) + define(["angular", "api-check"], factory); + else if(typeof exports === 'object') + exports["ngFormly"] = factory(require("angular"), require("api-check")); + else + root["ngFormly"] = factory(root["angular"], root["apiCheck"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _indexCommon = __webpack_require__(1); + + var _indexCommon2 = _interopRequireDefault(_indexCommon); + + exports['default'] = _indexCommon2['default']; + module.exports = exports['default']; + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + var _providersFormlyApiCheck = __webpack_require__(4); + + var _providersFormlyApiCheck2 = _interopRequireDefault(_providersFormlyApiCheck); + + var _otherDocsBaseUrl = __webpack_require__(6); + + var _otherDocsBaseUrl2 = _interopRequireDefault(_otherDocsBaseUrl); + + var _providersFormlyUsability = __webpack_require__(7); + + var _providersFormlyUsability2 = _interopRequireDefault(_providersFormlyUsability); + + var _providersFormlyConfig = __webpack_require__(8); + + var _providersFormlyConfig2 = _interopRequireDefault(_providersFormlyConfig); + + var _providersFormlyValidationMessages = __webpack_require__(10); + + var _providersFormlyValidationMessages2 = _interopRequireDefault(_providersFormlyValidationMessages); + + var _servicesFormlyUtil = __webpack_require__(11); + + var _servicesFormlyUtil2 = _interopRequireDefault(_servicesFormlyUtil); + + var _servicesFormlyWarn = __webpack_require__(12); + + var _servicesFormlyWarn2 = _interopRequireDefault(_servicesFormlyWarn); + + var _directivesFormlyCustomValidation = __webpack_require__(13); + + var _directivesFormlyCustomValidation2 = _interopRequireDefault(_directivesFormlyCustomValidation); + + var _directivesFormlyField = __webpack_require__(14); + + var _directivesFormlyField2 = _interopRequireDefault(_directivesFormlyField); + + var _directivesFormlyFocus = __webpack_require__(15); + + var _directivesFormlyFocus2 = _interopRequireDefault(_directivesFormlyFocus); + + var _directivesFormlyForm = __webpack_require__(16); + + var _directivesFormlyForm2 = _interopRequireDefault(_directivesFormlyForm); + + var _runFormlyNgModelAttrsManipulator = __webpack_require__(17); + + var _runFormlyNgModelAttrsManipulator2 = _interopRequireDefault(_runFormlyNgModelAttrsManipulator); + + var _runFormlyCustomTags = __webpack_require__(18); + + var _runFormlyCustomTags2 = _interopRequireDefault(_runFormlyCustomTags); + + var ngModuleName = 'formly'; + + exports['default'] = ngModuleName; + + var ngModule = _angularFix2['default'].module(ngModuleName, []); + + ngModule.constant('formlyApiCheck', _providersFormlyApiCheck2['default']); + ngModule.constant('formlyErrorAndWarningsUrlPrefix', _otherDocsBaseUrl2['default']); + ngModule.constant('formlyVersion', ("8.1.0")); // <-- webpack variable + + ngModule.provider('formlyUsability', _providersFormlyUsability2['default']); + ngModule.provider('formlyConfig', _providersFormlyConfig2['default']); + + ngModule.factory('formlyValidationMessages', _providersFormlyValidationMessages2['default']); + ngModule.factory('formlyUtil', _servicesFormlyUtil2['default']); + ngModule.factory('formlyWarn', _servicesFormlyWarn2['default']); + + ngModule.directive('formlyCustomValidation', _directivesFormlyCustomValidation2['default']); + ngModule.directive('formlyField', _directivesFormlyField2['default']); + ngModule.directive('formlyFocus', _directivesFormlyFocus2['default']); + ngModule.directive('formlyForm', _directivesFormlyForm2['default']); + + ngModule.run(_runFormlyNgModelAttrsManipulator2['default']); + ngModule.run(_runFormlyCustomTags2['default']); + module.exports = exports['default']; + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + // some versions of angular don't export the angular module properly, + // so we get it from window in this case. + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + var angular = __webpack_require__(3); + + /* istanbul ignore next */ + if (!angular.version) { + angular = window.angular; + } + exports['default'] = angular; + module.exports = exports['default']; + +/***/ }, +/* 3 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_3__; + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + var _apiCheck = __webpack_require__(5); + + var _apiCheck2 = _interopRequireDefault(_apiCheck); + + var apiCheck = (0, _apiCheck2['default'])({ + output: { + prefix: 'angular-formly:', + docsBaseUrl: __webpack_require__(6) + } + }); + + function shapeRequiredIfNot(otherProps, propChecker) { + if (!_angularFix2['default'].isArray(otherProps)) { + otherProps = [otherProps]; + } + var type = 'specified if these are not specified: `' + otherProps.join(', ') + '` (otherwise it\'s optional)'; + + function shapeRequiredIfNotDefinition(prop, propName, location, obj) { + var propExists = obj && obj.hasOwnProperty(propName); + var otherPropsExist = otherProps.some(function (otherProp) { + return obj && obj.hasOwnProperty(otherProp); + }); + if (!otherPropsExist && !propExists) { + return apiCheck.utils.getError(propName, location, type); + } else if (propExists) { + return propChecker(prop, propName, location, obj); + } + } + + shapeRequiredIfNotDefinition.type = type; + return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition); + } + + var formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func]); + var specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable; + + var apiCheckProperty = apiCheck.func; + + var apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({ + warn: apiCheck.func, + 'throw': apiCheck.func, + shape: apiCheck.func + })); + + var apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn'])); + + var formlyWrapperType = apiCheck.shape({ + name: shapeRequiredIfNot('types', apiCheck.string).optional, + template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional, + templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional, + types: apiCheck.typeOrArrayOf(apiCheck.string).optional, + overwriteOk: apiCheck.bool.optional, + apiCheck: apiCheckProperty.optional, + apiCheckInstance: apiCheckInstanceProperty.optional, + apiCheckFunction: apiCheckFunctionProperty.optional, + apiCheckOptions: apiCheck.object.optional + }).strict; + + var expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({ + expression: formlyExpression, + message: formlyExpression.optional + }).strict])); + + var modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object]); + + var templateManipulators = apiCheck.shape({ + preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional, + postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional + }).strict.nullable; + + var validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({ + expression: formlyExpression, + message: formlyExpression.optional + }).strict])); + + var watcherChecker = apiCheck.typeOrArrayOf(apiCheck.shape({ + expression: formlyExpression.optional, + listener: formlyExpression.optional, + runFieldExpressions: apiCheck.bool.optional + })); + + var fieldOptionsApiShape = { + $$hashKey: apiCheck.any.optional, + type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional, + template: apiCheck.shape.ifNot(['type', 'templateUrl'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional, + templateUrl: apiCheck.shape.ifNot(['type', 'template'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional, + key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional, + model: modelChecker.optional, + originalModel: modelChecker.optional, + className: apiCheck.string.optional, + id: apiCheck.string.optional, + name: apiCheck.string.optional, + expressionProperties: expressionProperties.optional, + extras: apiCheck.shape({ + validateOnModelChange: apiCheck.bool.optional, + skipNgModelAttrsManipulator: apiCheck.oneOfType([apiCheck.string, apiCheck.bool]).optional + }).strict.optional, + data: apiCheck.object.optional, + templateOptions: apiCheck.object.optional, + wrapper: specifyWrapperType.optional, + modelOptions: apiCheck.shape({ + updateOn: apiCheck.string.optional, + debounce: apiCheck.oneOfType([apiCheck.objectOf(apiCheck.number), apiCheck.number]).optional, + allowInvalid: apiCheck.bool.optional, + getterSetter: apiCheck.bool.optional, + timezone: apiCheck.string.optional + }).optional, + watcher: watcherChecker.optional, + validators: validatorChecker.optional, + asyncValidators: validatorChecker.optional, + parsers: apiCheck.arrayOf(formlyExpression).optional, + formatters: apiCheck.arrayOf(formlyExpression).optional, + noFormControl: apiCheck.bool.optional, + hide: apiCheck.bool.optional, + hideExpression: formlyExpression.optional, + ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional, + ngModelAttrs: apiCheck.objectOf(apiCheck.shape({ + statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional, + value: apiCheck.shape.ifNot('statement', apiCheck.any).optional, + attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional, + bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional, + boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional + }).strict).optional, + elementAttributes: apiCheck.objectOf(apiCheck.string).optional, + optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional, + link: apiCheck.func.optional, + controller: apiCheck.oneOfType([apiCheck.string, apiCheck.func, apiCheck.array]).optional, + validation: apiCheck.shape({ + show: apiCheck.bool.nullable.optional, + messages: apiCheck.objectOf(formlyExpression).optional, + errorExistsAndShouldBeVisible: apiCheck.bool.optional + }).optional, + formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional, + value: apiCheck.func.optional, + runExpressions: apiCheck.func.optional, + templateManipulators: templateManipulators.optional, + resetModel: apiCheck.func.optional, + updateInitialValue: apiCheck.func.optional, + initialValue: apiCheck.any.optional, + defaultValue: apiCheck.any.optional + }; + + var formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict; + + var formOptionsApi = apiCheck.shape({ + formState: apiCheck.object.optional, + resetModel: apiCheck.func.optional, + updateInitialValue: apiCheck.func.optional, + removeChromeAutoComplete: apiCheck.bool.optional, + templateManipulators: templateManipulators.optional, + manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional, + watchAllExpressions: apiCheck.bool.optional, + wrapper: specifyWrapperType.optional, + fieldTransform: apiCheck.oneOfType([apiCheck.func, apiCheck.array]).optional, + data: apiCheck.object.optional + }).strict; + + var fieldGroup = apiCheck.shape({ + $$hashKey: apiCheck.any.optional, + key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional, + // danger. Nested field groups wont get api-checked... + fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])), + className: apiCheck.string.optional, + options: formOptionsApi.optional, + templateOptions: apiCheck.object.optional, + wrapper: specifyWrapperType.optional, + watcher: watcherChecker.optional, + hide: apiCheck.bool.optional, + hideExpression: formlyExpression.optional, + data: apiCheck.object.optional, + model: modelChecker.optional, + form: apiCheck.object.optional, + elementAttributes: apiCheck.objectOf(apiCheck.string).optional + }).strict; + + var typeOptionsDefaultOptions = _angularFix2['default'].copy(fieldOptionsApiShape); + typeOptionsDefaultOptions.key = apiCheck.string.optional; + + var formlyTypeOptions = apiCheck.shape({ + name: apiCheck.string, + template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional, + templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional, + controller: apiCheck.oneOfType([apiCheck.func, apiCheck.string, apiCheck.array]).optional, + link: apiCheck.func.optional, + defaultOptions: apiCheck.oneOfType([apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions)]).optional, + 'extends': apiCheck.string.optional, + wrapper: specifyWrapperType.optional, + data: apiCheck.object.optional, + apiCheck: apiCheckProperty.optional, + apiCheckInstance: apiCheckInstanceProperty.optional, + apiCheckFunction: apiCheckFunctionProperty.optional, + apiCheckOptions: apiCheck.object.optional, + overwriteOk: apiCheck.bool.optional + }).strict; + + _angularFix2['default'].extend(apiCheck, { + formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi + }); + + exports['default'] = apiCheck; + module.exports = exports['default']; + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_5__; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports["default"] = "https://github.com/formly-js/angular-formly/blob/" + ("8.1.0") + "/other/ERRORS_AND_WARNINGS.md#"; + module.exports = exports["default"]; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + formlyUsability.$inject = ["formlyApiCheck", "formlyErrorAndWarningsUrlPrefix"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + exports['default'] = formlyUsability; + + // @ngInject + function formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) { + var _this = this; + + _angularFix2['default'].extend(this, { + getFormlyError: getFormlyError, + getFieldError: getFieldError, + checkWrapper: checkWrapper, + checkWrapperTemplate: checkWrapperTemplate, + getErrorMessage: getErrorMessage, + $get: function $get() { + return _this; + } + }); + + function getFieldError(errorInfoSlug, message, field) { + if (arguments.length < 3) { + field = message; + message = errorInfoSlug; + errorInfoSlug = null; + } + return new Error(getErrorMessage(errorInfoSlug, message) + (' Field definition: ' + _angularFix2['default'].toJson(field))); + } + + function getFormlyError(errorInfoSlug, message) { + if (!message) { + message = errorInfoSlug; + errorInfoSlug = null; + } + return new Error(getErrorMessage(errorInfoSlug, message)); + } + + function getErrorMessage(errorInfoSlug, message) { + var url = ''; + if (errorInfoSlug !== null) { + url = '' + formlyErrorAndWarningsUrlPrefix + errorInfoSlug; + } + return 'Formly Error: ' + message + '. ' + url; + } + + function checkWrapper(wrapper) { + formlyApiCheck['throw'](formlyApiCheck.formlyWrapperType, wrapper, { + prefix: 'formlyConfig.setWrapper', + urlSuffix: 'setwrapper-validation-failed' + }); + } + + function checkWrapperTemplate(template, additionalInfo) { + var formlyTransclude = ''; + if (template.indexOf(formlyTransclude) === -1) { + throw getFormlyError('Template wrapper templates must use "' + formlyTransclude + '" somewhere in them. ' + ('This one does not have "" in it: ' + template) + '\n' + ('Additional information: ' + JSON.stringify(additionalInfo))); + } + } + } + module.exports = exports['default']; + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + formlyConfig.$inject = ["formlyUsabilityProvider", "formlyErrorAndWarningsUrlPrefix", "formlyApiCheck"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + var _otherUtils = __webpack_require__(9); + + var _otherUtils2 = _interopRequireDefault(_otherUtils); + + exports['default'] = formlyConfig; + + // @ngInject + function formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) { + var _this2 = this; + + var typeMap = {}; + var templateWrappersMap = {}; + var defaultWrapperName = 'default'; + var _this = this; + var getError = formlyUsabilityProvider.getFormlyError; + + _angularFix2['default'].extend(this, { + setType: setType, + getType: getType, + getTypes: getTypes, + getTypeHeritage: getTypeHeritage, + setWrapper: setWrapper, + getWrapper: getWrapper, + getWrapperByType: getWrapperByType, + removeWrapperByName: removeWrapperByName, + removeWrappersForType: removeWrappersForType, + disableWarnings: false, + extras: { + disableNgModelAttrsManipulator: false, + fieldTransform: [], + ngModelAttrsManipulatorPreferUnbound: false, + removeChromeAutoComplete: false, + defaultHideDirective: 'ng-if', + getFieldId: null + }, + templateManipulators: { + preWrapper: [], + postWrapper: [] + }, + $get: function $get() { + return _this2; + } + }); + + function setType(options) { + if (_angularFix2['default'].isArray(options)) { + var _ret = (function () { + var allTypes = []; + _angularFix2['default'].forEach(options, function (item) { + allTypes.push(setType(item)); + }); + return { + v: allTypes + }; + })(); + + if (typeof _ret === 'object') return _ret.v; + } else if (_angularFix2['default'].isObject(options)) { + checkType(options); + if (options['extends']) { + extendTypeOptions(options); + } + typeMap[options.name] = options; + return typeMap[options.name]; + } else { + throw getError('You must provide an object or array for setType. You provided: ' + JSON.stringify(arguments)); + } + } + + function checkType(options) { + formlyApiCheck['throw'](formlyApiCheck.formlyTypeOptions, options, { + prefix: 'formlyConfig.setType', + url: 'settype-validation-failed' + }); + if (!options.overwriteOk) { + checkOverwrite(options.name, typeMap, options, 'types'); + } else { + options.overwriteOk = undefined; + } + } + + function extendTypeOptions(options) { + var extendsType = getType(options['extends'], true, options); + extendTypeControllerFunction(options, extendsType); + extendTypeLinkFunction(options, extendsType); + extendTypeDefaultOptions(options, extendsType); + _otherUtils2['default'].reverseDeepMerge(options, extendsType); + extendTemplate(options, extendsType); + } + + function extendTemplate(options, extendsType) { + if (options.template && extendsType.templateUrl) { + delete options.templateUrl; + } else if (options.templateUrl && extendsType.template) { + delete options.template; + } + } + + function extendTypeControllerFunction(options, extendsType) { + var extendsCtrl = extendsType.controller; + if (!_angularFix2['default'].isDefined(extendsCtrl)) { + return; + } + var optionsCtrl = options.controller; + if (_angularFix2['default'].isDefined(optionsCtrl)) { + options.controller = function ($scope, $controller) { + $controller(extendsCtrl, { $scope: $scope }); + $controller(optionsCtrl, { $scope: $scope }); + }; + options.controller.$inject = ['$scope', '$controller']; + } else { + options.controller = extendsCtrl; + } + } + + function extendTypeLinkFunction(options, extendsType) { + var extendsFn = extendsType.link; + if (!_angularFix2['default'].isDefined(extendsFn)) { + return; + } + var optionsFn = options.link; + if (_angularFix2['default'].isDefined(optionsFn)) { + options.link = function () { + extendsFn.apply(undefined, arguments); + optionsFn.apply(undefined, arguments); + }; + } else { + options.link = extendsFn; + } + } + + function extendTypeDefaultOptions(options, extendsType) { + var extendsDO = extendsType.defaultOptions; + if (!_angularFix2['default'].isDefined(extendsDO)) { + return; + } + var optionsDO = options.defaultOptions; + var optionsDOIsFn = _angularFix2['default'].isFunction(optionsDO); + var extendsDOIsFn = _angularFix2['default'].isFunction(extendsDO); + if (extendsDOIsFn) { + options.defaultOptions = function defaultOptions(opts, scope) { + var extendsDefaultOptions = extendsDO(opts, scope); + var mergedDefaultOptions = {}; + _otherUtils2['default'].reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions); + var extenderOptionsDefaultOptions = optionsDO; + if (optionsDOIsFn) { + extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope); + } + _otherUtils2['default'].reverseDeepMerge(extendsDefaultOptions, extenderOptionsDefaultOptions); + return extendsDefaultOptions; + }; + } else if (optionsDOIsFn) { + options.defaultOptions = function defaultOptions(opts, scope) { + var newDefaultOptions = {}; + _otherUtils2['default'].reverseDeepMerge(newDefaultOptions, opts, extendsDO); + return optionsDO(newDefaultOptions, scope); + }; + } + } + + function getType(name, throwError, errorContext) { + if (!name) { + return undefined; + } + var type = typeMap[name]; + if (!type && throwError === true) { + throw getError('There is no type by the name of "' + name + '": ' + JSON.stringify(errorContext)); + } else { + return type; + } + } + + function getTypes() { + return typeMap; + } + + function getTypeHeritage(parent) { + var heritage = []; + var type = parent; + if (_angularFix2['default'].isString(type)) { + type = getType(parent); + } + parent = type['extends']; + while (parent) { + type = getType(parent); + heritage.push(type); + parent = type['extends']; + } + return heritage; + } + + function setWrapper(_x, _x2) { + var _again = true; + + _function: while (_again) { + var options = _x, + name = _x2; + _again = false; + + if (_angularFix2['default'].isArray(options)) { + return options.map(function (wrapperOptions) { + return setWrapper(wrapperOptions); + }); + } else if (_angularFix2['default'].isObject(options)) { + options.types = getOptionsTypes(options); + options.name = getOptionsName(options, name); + checkWrapperAPI(options); + templateWrappersMap[options.name] = options; + return options; + } else if (_angularFix2['default'].isString(options)) { + _x = { + template: options, + name: name + }; + _x2 = undefined; + _again = true; + continue _function; + } + } + } + + function getOptionsTypes(options) { + if (_angularFix2['default'].isString(options.types)) { + return [options.types]; + } + if (!_angularFix2['default'].isDefined(options.types)) { + return []; + } else { + return options.types; + } + } + + function getOptionsName(options, name) { + return options.name || name || options.types.join(' ') || defaultWrapperName; + } + + function checkWrapperAPI(options) { + formlyUsabilityProvider.checkWrapper(options); + if (options.template) { + formlyUsabilityProvider.checkWrapperTemplate(options.template, options); + } + if (!options.overwriteOk) { + checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers'); + } else { + delete options.overwriteOk; + } + checkWrapperTypes(options); + } + + function checkWrapperTypes(options) { + var shouldThrow = !_angularFix2['default'].isArray(options.types) || !options.types.every(_angularFix2['default'].isString); + if (shouldThrow) { + throw getError('Attempted to create a template wrapper with types that is not a string or an array of strings'); + } + } + + function checkOverwrite(property, object, newValue, objectName) { + if (object.hasOwnProperty(property)) { + warn('overwriting-types-or-wrappers', ['Attempting to overwrite ' + property + ' on ' + objectName + ' which is currently', JSON.stringify(object[property]) + ' with ' + JSON.stringify(newValue), 'To supress this warning, specify the property "overwriteOk: true"'].join(' ')); + } + } + + function getWrapper(name) { + return templateWrappersMap[name || defaultWrapperName]; + } + + function getWrapperByType(type) { + /* eslint prefer-const:0 */ + var wrappers = []; + for (var _name in templateWrappersMap) { + if (templateWrappersMap.hasOwnProperty(_name)) { + if (templateWrappersMap[_name].types && templateWrappersMap[_name].types.indexOf(type) !== -1) { + wrappers.push(templateWrappersMap[_name]); + } + } + } + return wrappers; + } + + function removeWrapperByName(name) { + var wrapper = templateWrappersMap[name]; + delete templateWrappersMap[name]; + return wrapper; + } + + function removeWrappersForType(type) { + var wrappers = getWrapperByType(type); + if (!wrappers) { + return undefined; + } + if (!_angularFix2['default'].isArray(wrappers)) { + return removeWrapperByName(wrappers.name); + } else { + wrappers.forEach(function (wrapper) { + return removeWrapperByName(wrapper.name); + }); + return wrappers; + } + } + + function warn() { + if (!_this.disableWarnings && console.warn) { + /* eslint no-console:0 */ + var args = Array.prototype.slice.call(arguments); + var warnInfoSlug = args.shift(); + args.unshift('Formly Warning:'); + args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug); + console.warn.apply(console, _toConsumableArray(args)); + } + } + } + module.exports = exports['default']; + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + exports['default'] = { + containsSelector: containsSelector, containsSpecialChar: containsSpecialChar, formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName, + arrayify: arrayify, extendFunction: extendFunction, extendArray: extendArray, startsWith: startsWith, contains: contains + }; + + function containsSelector(string) { + return containsSpecialChar(string, '.') || containsSpecialChar(string, '[') && containsSpecialChar(string, ']'); + } + + function containsSpecialChar(a, b) { + if (!a || !a.indexOf) { + return false; + } + return a.indexOf(b) !== -1; + } + + function formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) { + if (_angularFix2['default'].isFunction(expression)) { + return expression($viewValue, $modelValue, scope, extraLocals); + } else { + return scope.$eval(expression, _angularFix2['default'].extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals)); + } + } + + function getFieldId(formId, options, index) { + if (options.id) { + return options.id; + } + var type = options.type; + if (!type && options.template) { + type = 'template'; + } else if (!type && options.templateUrl) { + type = 'templateUrl'; + } + + return [formId, type, options.key, index].join('_'); + } + + function reverseDeepMerge(dest) { + _angularFix2['default'].forEach(arguments, function (src, index) { + if (!index) { + return; + } + _angularFix2['default'].forEach(src, function (val, prop) { + if (!_angularFix2['default'].isDefined(dest[prop])) { + dest[prop] = _angularFix2['default'].copy(val); + } else if (objAndSameType(dest[prop], val)) { + reverseDeepMerge(dest[prop], val); + } + }); + }); + return dest; + } + + function objAndSameType(obj1, obj2) { + return _angularFix2['default'].isObject(obj1) && _angularFix2['default'].isObject(obj2) && Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2); + } + + // recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8 + function findByNodeName(el, nodeName) { + if (!el.prop) { + // not a jQuery or jqLite object -> wrap it + el = _angularFix2['default'].element(el); + } + + if (el.prop('nodeName') === nodeName.toUpperCase()) { + return el; + } + + var c = el.children(); + for (var i = 0; c && i < c.length; i++) { + var node = findByNodeName(c[i], nodeName); + if (node) { + return node; + } + } + } + + function arrayify(obj) { + if (obj && !_angularFix2['default'].isArray(obj)) { + obj = [obj]; + } else if (!obj) { + obj = []; + } + return obj; + } + + function extendFunction() { + for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) { + fns[_key] = arguments[_key]; + } + + return function extendedFunction() { + var args = arguments; + fns.forEach(function (fn) { + return fn.apply(null, args); + }); + }; + } + + function extendArray(primary, secondary, property) { + if (property) { + primary = primary[property]; + secondary = secondary[property]; + } + if (secondary && primary) { + _angularFix2['default'].forEach(secondary, function (item) { + if (primary.indexOf(item) === -1) { + primary.push(item); + } + }); + return primary; + } else if (secondary) { + return secondary; + } else { + return primary; + } + } + + function startsWith(str, search) { + if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) { + return str.length >= search.length && str.substring(0, search.length) === search; + } else { + return false; + } + } + + function contains(str, search) { + if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) { + return str.length >= search.length && str.indexOf(search) !== -1; + } else { + return false; + } + } + module.exports = exports['default']; + +/***/ }, +/* 10 */ +/***/ function(module, exports) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + exports['default'] = formlyValidationMessages; + + // @ngInject + function formlyValidationMessages() { + + var validationMessages = { + addTemplateOptionValueMessage: addTemplateOptionValueMessage, + addStringMessage: addStringMessage, + messages: {} + }; + + return validationMessages; + + function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) { + validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate); + } + + function addStringMessage(name, string) { + validationMessages.messages[name] = function () { + return string; + }; + } + + function templateOptionValue(prop, prefix, suffix, alternate) { + return function getValidationMessage(viewValue, modelValue, scope) { + if (typeof scope.options.templateOptions[prop] !== 'undefined') { + return prefix + ' ' + scope.options.templateOptions[prop] + ' ' + suffix; + } else { + return alternate; + } + }; + } + } + module.exports = exports['default']; + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _otherUtils = __webpack_require__(9); + + var _otherUtils2 = _interopRequireDefault(_otherUtils); + + exports['default'] = formlyUtil; + + // @ngInject + function formlyUtil() { + return _otherUtils2['default']; + } + module.exports = exports['default']; + +/***/ }, +/* 12 */ +/***/ function(module, exports) { + + 'use strict'; + + formlyWarn.$inject = ["formlyConfig", "formlyErrorAndWarningsUrlPrefix", "$log"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } } + + exports['default'] = formlyWarn; + + // @ngInject + function formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) { + return function warn() { + if (!formlyConfig.disableWarnings) { + var args = Array.prototype.slice.call(arguments); + var warnInfoSlug = args.shift(); + args.unshift('Formly Warning:'); + args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug); + $log.warn.apply($log, _toConsumableArray(args)); + } + }; + } + module.exports = exports['default']; + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + formlyCustomValidation.$inject = ["formlyUtil"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + exports['default'] = formlyCustomValidation; + + // @ngInject + function formlyCustomValidation(formlyUtil) { + return { + restrict: 'A', + require: 'ngModel', + link: function formlyCustomValidationLink(scope, el, attrs, ctrl) { + var opts = scope.options; + opts.validation.messages = opts.validation.messages || {}; + _angularFix2['default'].forEach(opts.validation.messages, function (message, key) { + opts.validation.messages[key] = function () { + return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue); + }; + }); + + var useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers'); + _angularFix2['default'].forEach(opts.validators, _angularFix2['default'].bind(null, addValidatorToPipeline, false)); + _angularFix2['default'].forEach(opts.asyncValidators, _angularFix2['default'].bind(null, addValidatorToPipeline, true)); + + function addValidatorToPipeline(isAsync, validator, name) { + setupMessage(validator, name); + validator = _angularFix2['default'].isObject(validator) ? validator.expression : validator; + if (useNewValidatorsApi) { + setupWithValidators(validator, name, isAsync); + } else { + setupWithParsers(validator, name, isAsync); + } + } + + function setupMessage(validator, name) { + var message = validator.message; + if (message) { + opts.validation.messages[name] = function () { + return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue); + }; + } + } + + function setupWithValidators(validator, name, isAsync) { + var validatorCollection = isAsync ? '$asyncValidators' : '$validators'; + + ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) { + return formlyUtil.formlyEval(scope, validator, modelValue, viewValue); + }; + } + + function setupWithParsers(validator, name, isAsync) { + var inFlightValidator = undefined; + ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) { + var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue); + if (isAsync) { + ctrl.$pending = ctrl.$pending || {}; + ctrl.$pending[name] = true; + inFlightValidator = isValid; + isValid.then(function () { + if (inFlightValidator === isValid) { + ctrl.$setValidity(name, true); + } + })['catch'](function () { + if (inFlightValidator === isValid) { + ctrl.$setValidity(name, false); + } + })['finally'](function () { + var $pending = ctrl.$pending || {}; + if (Object.keys($pending).length === 1) { + delete ctrl.$pending; + } else { + delete ctrl.$pending[name]; + } + }); + } else { + ctrl.$setValidity(name, isValid); + } + return viewValue; + }); + } + } + }; + } + module.exports = exports['default']; + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + formlyField.$inject = ["$http", "$q", "$compile", "$templateCache", "$interpolate", "formlyConfig", "formlyApiCheck", "formlyUtil", "formlyUsability", "formlyWarn"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + var _apiCheck = __webpack_require__(5); + + var _apiCheck2 = _interopRequireDefault(_apiCheck); + + exports['default'] = formlyField; + + /** + * @ngdoc directive + * @name formlyField + * @restrict AE + */ + // @ngInject + function formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) { + FormlyFieldController.$inject = ["$scope", "$timeout", "$parse", "$controller", "formlyValidationMessages"]; + var arrayify = formlyUtil.arrayify; + + return { + restrict: 'AE', + transclude: true, + require: '?^formlyForm', + scope: { + options: '=', + model: '=', + originalModel: '=?', + formId: '@', // TODO remove formId in a breaking release + index: '=?', + fields: '=?', + formState: '=?', + formOptions: '=?', + form: '=?' }, + // TODO require form in a breaking release + controller: FormlyFieldController, + link: fieldLink + }; + + // @ngInject + function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) { + /* eslint max-statements:[2, 34] */ + if ($scope.options.fieldGroup) { + setupFieldGroup(); + return; + } + + var fieldType = getFieldType($scope.options); + simplifyLife($scope.options); + mergeFieldOptionsWithTypeDefaults($scope.options, fieldType); + extendOptionsWithDefaults($scope.options, $scope.index); + checkApi($scope.options); + // set field id to link labels and fields + + // initalization + setFieldIdAndName(); + setDefaultValue(); + setInitialValue(); + runExpressions(); + watchExpressions(); + addValidationMessages($scope.options); + invokeControllers($scope, $scope.options, fieldType); + + // function definitions + function runExpressions() { + // must run on next tick to make sure that the current value is correct. + return $timeout(function runExpressionsOnNextTick() { + var field = $scope.options; + var currentValue = valueGetterSetter(); + _angularFix2['default'].forEach(field.expressionProperties, function runExpression(expression, prop) { + var setter = $parse(prop).assign; + var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue)); + promise.then(function setFieldValue(value) { + setter(field, value); + }); + }); + }, 0, false); + } + + function watchExpressions() { + if ($scope.formOptions.watchAllExpressions) { + (function () { + var field = $scope.options; + var currentValue = valueGetterSetter(); + _angularFix2['default'].forEach(field.expressionProperties, function watchExpression(expression, prop) { + var setter = $parse(prop).assign; + $scope.$watch(function expressionPropertyWatcher() { + return formlyUtil.formlyEval($scope, expression, currentValue, currentValue); + }, function expressionPropertyListener(value) { + setter(field, value); + }, true); + }); + })(); + } + } + + function valueGetterSetter(newVal) { + if (!$scope.model || !$scope.options.key) { + return undefined; + } + if (_angularFix2['default'].isDefined(newVal)) { + parseSet($scope.options.key, $scope.model, newVal); + } + return parseGet($scope.options.key, $scope.model); + } + + function shouldNotUseParseKey(key) { + return _angularFix2['default'].isNumber(key) || !formlyUtil.containsSelector(key); + } + + function parseSet(key, model, newVal) { + // If either of these are null/undefined then just return undefined + if (!key && key !== 0 || !model) { + return; + } + // If we are working with a number then $parse wont work, default back to the old way for now + if (shouldNotUseParseKey(key)) { + // TODO: Fix this so we can get several levels instead of just one with properties that are numeric + model[key] = newVal; + } else { + var setter = $parse($scope.options.key).assign; + if (setter) { + setter($scope.model, newVal); + } + } + } + + function parseGet(key, model) { + // If either of these are null/undefined then just return undefined + if (!key && key !== 0 || !model) { + return undefined; + } + + // If we are working with a number then $parse wont work, default back to the old way for now + if (shouldNotUseParseKey(key)) { + // TODO: Fix this so we can get several levels instead of just one with properties that are numeric + return model[key]; + } else { + return $parse(key)(model); + } + } + + function simplifyLife(options) { + // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere + formlyUtil.reverseDeepMerge(options, { + originalModel: options.model, + extras: {}, + data: {}, + templateOptions: {}, + validation: {} + }); + // create $scope.to so template authors can reference to instead of $scope.options.templateOptions + $scope.to = $scope.options.templateOptions; + $scope.formOptions = $scope.formOptions || {}; + } + + function setFieldIdAndName() { + if (_angularFix2['default'].isFunction(formlyConfig.extras.getFieldId)) { + $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope); + } else { + var formName = $scope.form && $scope.form.$name || $scope.formId; + $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index); + } + $scope.options.id = $scope.id; + $scope.name = $scope.options.name || $scope.options.id; + $scope.options.name = $scope.name; + } + + function setDefaultValue() { + if (_angularFix2['default'].isDefined($scope.options.defaultValue) && !_angularFix2['default'].isDefined(parseGet($scope.options.key, $scope.model))) { + parseSet($scope.options.key, $scope.model, $scope.options.defaultValue); + } + } + + function setInitialValue() { + $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model); + } + + function mergeFieldOptionsWithTypeDefaults(options, type) { + if (type) { + mergeOptions(options, type.defaultOptions); + } + var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden + _angularFix2['default'].forEach(properOrder, function (typeName) { + mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions); + }); + } + + function mergeOptions(options, extraOptions) { + if (extraOptions) { + if (_angularFix2['default'].isFunction(extraOptions)) { + extraOptions = extraOptions(options, $scope); + } + formlyUtil.reverseDeepMerge(options, extraOptions); + } + } + + function extendOptionsWithDefaults(options, index) { + var key = options.key || index || 0; + _angularFix2['default'].extend(options, { + // attach the key in case the formly-field directive is used directly + key: key, + value: options.value || valueGetterSetter, + runExpressions: runExpressions, + resetModel: resetModel, + updateInitialValue: updateInitialValue + }); + } + + function resetModel() { + parseSet($scope.options.key, $scope.model, $scope.options.initialValue); + if ($scope.options.formControl) { + if (_angularFix2['default'].isArray($scope.options.formControl)) { + _angularFix2['default'].forEach($scope.options.formControl, function (formControl) { + resetFormControl(formControl, true); + }); + } else { + resetFormControl($scope.options.formControl); + } + } + if ($scope.form) { + $scope.form.$setUntouched && $scope.form.$setUntouched(); + $scope.form.$setPristine(); + } + } + + function resetFormControl(formControl, isMultiNgModel) { + if (!isMultiNgModel) { + formControl.$setViewValue(parseGet($scope.options.key, $scope.model)); + } + + formControl.$render(); + formControl.$setUntouched && formControl.$setUntouched(); + formControl.$setPristine(); + + // To prevent breaking change requiring a digest to reset $viewModel + if (!$scope.$root.$$phase) { + $scope.$digest(); + } + } + + function updateInitialValue() { + $scope.options.initialValue = parseGet($scope.options.key, $scope.model); + } + + function addValidationMessages(options) { + options.validation.messages = options.validation.messages || {}; + _angularFix2['default'].forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) { + if (!options.validation.messages[name]) { + options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) { + return formlyUtil.formlyEval(scope, expression, modelValue, viewValue); + }; + } + }); + } + + function invokeControllers(scope) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + var type = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + _angularFix2['default'].forEach([type.controller, options.controller], function (controller) { + if (controller) { + $controller(controller, { $scope: scope }); + } + }); + } + + function setupFieldGroup() { + $scope.options.options = $scope.options.options || {}; + $scope.options.options.formState = $scope.formState; + $scope.to = $scope.options.templateOptions; + } + } + + // link function + function fieldLink(scope, el, attrs, formlyFormCtrl) { + if (scope.options.fieldGroup) { + setFieldGroupTemplate(); + return; + } + + // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead) + if (!formlyFormCtrl && scope.options.model) { + scope.$watch('options.model', function () { + return scope.options.runExpressions(); + }, true); + } + + addAttributes(); + addClasses(); + + var type = getFieldType(scope.options); + var args = arguments; + var thusly = this; + var fieldCount = 0; + var fieldManipulators = getManipulators(scope.options, scope.formOptions); + getFieldTemplate(scope.options).then(runManipulators(fieldManipulators.preWrapper)).then(transcludeInWrappers(scope.options, scope.formOptions)).then(runManipulators(fieldManipulators.postWrapper)).then(setElementTemplate).then(watchFormControl).then(callLinkFunctions)['catch'](function (error) { + formlyWarn('there-was-a-problem-setting-the-template-for-this-field', 'There was a problem setting the template for this field ', scope.options, error); + }); + + function setFieldGroupTemplate() { + checkFieldGroupApi(scope.options); + el.addClass('formly-field-group'); + var extraAttributes = ''; + if (scope.options.elementAttributes) { + extraAttributes = Object.keys(scope.options.elementAttributes).map(function (key) { + return key + '="' + scope.options.elementAttributes[key] + '"'; + }).join(' '); + } + var modelValue = 'model'; + scope.options.form = scope.form; + if (scope.options.key) { + modelValue = 'model[\'' + scope.options.key + '\']'; + } + getTemplate('\n \n \n ').then(transcludeInWrappers(scope.options, scope.formOptions)).then(setElementTemplate); + } + + function addAttributes() { + if (scope.options.elementAttributes) { + el.attr(scope.options.elementAttributes); + } + } + + function addClasses() { + if (scope.options.className) { + el.addClass(scope.options.className); + } + if (scope.options.type) { + el.addClass('formly-field-' + scope.options.type); + } + } + + function setElementTemplate(templateString) { + el.html(asHtml(templateString)); + $compile(el.contents())(scope); + return templateString; + } + + function watchFormControl(templateString) { + var stopWatchingShowError = _angularFix2['default'].noop; + if (scope.options.noFormControl) { + return; + } + var templateEl = _angularFix2['default'].element('
' + templateString + '
'); + var ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]'); + + if (ngModelNodes.length) { + _angularFix2['default'].forEach(ngModelNodes, function (ngModelNode) { + fieldCount++; + watchFieldNameOrExistence(ngModelNode.getAttribute('name')); + }); + } + + function watchFieldNameOrExistence(name) { + var nameExpressionRegex = /\{\{(.*?)}}/; + var nameExpression = nameExpressionRegex.exec(name); + if (nameExpression) { + name = $interpolate(name)(scope); + } + watchFieldExistence(name); + } + + function watchFieldExistence(name) { + scope.$watch('form["' + name + '"]', function formControlChange(formControl) { + if (formControl) { + if (fieldCount > 1) { + if (!scope.options.formControl) { + scope.options.formControl = []; + } + scope.options.formControl.push(formControl); + } else { + scope.options.formControl = formControl; + } + scope.fc = scope.options.formControl; // shortcut for template authors + stopWatchingShowError(); + addShowMessagesWatcher(); + addParsers(); + addFormatters(); + } + }); + } + + function addShowMessagesWatcher() { + stopWatchingShowError = scope.$watch(function watchShowValidationChange() { + var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression; + var options = scope.options; + var formControls = arrayify(scope.fc); + if (!formControls.some(function (fc) { + return fc.$invalid; + })) { + return false; + } else if (typeof options.validation.show === 'boolean') { + return options.validation.show; + } else if (customExpression) { + return formControls.some(function (fc) { + return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue); + }); + } else { + return formControls.some(function (fc) { + var noTouchedButDirty = _angularFix2['default'].isUndefined(fc.$touched) && fc.$dirty; + return fc.$touched || noTouchedButDirty; + }); + } + }, function onShowValidationChange(show) { + scope.options.validation.errorExistsAndShouldBeVisible = show; + scope.showError = show; // shortcut for template authors + }); + } + + function addParsers() { + setParsersOrFormatters('parsers'); + } + + function addFormatters() { + setParsersOrFormatters('formatters'); + var ctrl = scope.fc; + var formWasPristine = scope.form.$pristine; + if (scope.options.formatters) { + (function () { + var value = ctrl.$modelValue; + ctrl.$formatters.forEach(function (formatter) { + value = formatter(value); + }); + + ctrl.$setViewValue(value); + ctrl.$render(); + ctrl.$setPristine(); + if (formWasPristine) { + scope.form.$setPristine(); + } + })(); + } + } + + function setParsersOrFormatters(which) { + var originalThingProp = 'originalParser'; + if (which === 'formatters') { + originalThingProp = 'originalFormatter'; + } + + // init with type's parsers + var things = getThingsFromType(type); + + // get optionsTypes things + things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes)); + + // get field's things + things = formlyUtil.extendArray(things, scope.options[which]); + + // convert things into formlyExpression things + _angularFix2['default'].forEach(things, function (thing, index) { + things[index] = getFormlyExpressionThing(thing); + }); + + var ngModelCtrls = scope.fc; + if (!_angularFix2['default'].isArray(ngModelCtrls)) { + ngModelCtrls = [ngModelCtrls]; + } + + _angularFix2['default'].forEach(ngModelCtrls, function (ngModelCtrl) { + var _ngModelCtrl; + + ngModelCtrl['$' + which] = (_ngModelCtrl = ngModelCtrl['$' + which]).concat.apply(_ngModelCtrl, _toConsumableArray(things)); + }); + + function getThingsFromType(theType) { + if (!theType) { + return []; + } + if (_angularFix2['default'].isString(theType)) { + theType = formlyConfig.getType(theType, true, scope.options); + } + var typeThings = []; + + // get things from parent + if (theType['extends']) { + typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType['extends'])); + } + + // get own type's things + typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, [])); + + // get things from optionsTypes + typeThings = formlyUtil.extendArray(typeThings, getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType))); + + return typeThings; + } + + function getThingsFromOptionsTypes() { + var optionsTypes = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0]; + + var optionsTypesThings = []; + _angularFix2['default'].forEach(_angularFix2['default'].copy(arrayify(optionsTypes)).reverse(), function (optionsTypeName) { + optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName)); + }); + return optionsTypesThings; + } + + function getFormlyExpressionThing(thing) { + formlyExpressionParserOrFormatterFunction[originalThingProp] = thing; + return formlyExpressionParserOrFormatterFunction; + + function formlyExpressionParserOrFormatterFunction($viewValue) { + var $modelValue = scope.options.value(); + return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue); + } + } + } + } + + function callLinkFunctions() { + if (type && type.link) { + type.link.apply(thusly, args); + } + if (scope.options.link) { + scope.options.link.apply(thusly, args); + } + } + + function runManipulators(manipulators) { + return function runManipulatorsOnTemplate(templateToManipulate) { + var chain = $q.when(templateToManipulate); + _angularFix2['default'].forEach(manipulators, function (manipulator) { + chain = chain.then(function (template) { + return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) { + return _angularFix2['default'].isString(newTemplate) ? newTemplate : asHtml(newTemplate); + }); + }); + }); + return chain; + }; + } + } + + // sort-of stateless util functions + function asHtml(el) { + var wrapper = _angularFix2['default'].element(''); + return wrapper.append(el).html(); + } + + function getFieldType(options) { + return options.type && formlyConfig.getType(options.type); + } + + function getManipulators(options, formOptions) { + var preWrapper = []; + var postWrapper = []; + addManipulators(options.templateManipulators); + addManipulators(formOptions.templateManipulators); + addManipulators(formlyConfig.templateManipulators); + return { preWrapper: preWrapper, postWrapper: postWrapper }; + + function addManipulators(manipulators) { + /* eslint-disable */ // it doesn't understand this :-( + + var _ref = manipulators || {}; + + var _ref$preWrapper = _ref.preWrapper; + var pre = _ref$preWrapper === undefined ? [] : _ref$preWrapper; + var _ref$postWrapper = _ref.postWrapper; + var post = _ref$postWrapper === undefined ? [] : _ref$postWrapper; + + preWrapper = preWrapper.concat(pre); + postWrapper = postWrapper.concat(post); + /* eslint-enable */ + } + } + + function getFieldTemplate(options) { + function fromOptionsOrType(key, fieldType) { + if (_angularFix2['default'].isDefined(options[key])) { + return options[key]; + } else if (fieldType && _angularFix2['default'].isDefined(fieldType[key])) { + return fieldType[key]; + } + } + + var type = formlyConfig.getType(options.type, true, options); + var template = fromOptionsOrType('template', type); + var templateUrl = fromOptionsOrType('templateUrl', type); + if (_angularFix2['default'].isUndefined(template) && !templateUrl) { + throw formlyUsability.getFieldError('type-type-has-no-template', 'Type \'' + options.type + '\' has no template. On element:', options); + } + + return getTemplate(templateUrl || template, _angularFix2['default'].isUndefined(template), options); + } + + function getTemplate(template, isUrl, options) { + var templatePromise = undefined; + if (_angularFix2['default'].isFunction(template)) { + templatePromise = $q.when(template(options)); + } else { + templatePromise = $q.when(template); + } + + if (!isUrl) { + return templatePromise; + } else { + var _ret3 = (function () { + var httpOptions = { cache: $templateCache }; + return { + v: templatePromise.then(function (url) { + return $http.get(url, httpOptions); + }).then(function (response) { + return response.data; + })['catch'](function handleErrorGettingATemplate(error) { + formlyWarn('problem-loading-template-for-templateurl', 'Problem loading template for ' + template, error); + }) + }; + })(); + + if (typeof _ret3 === 'object') return _ret3.v; + } + } + + function transcludeInWrappers(options, formOptions) { + var wrapper = getWrapperOption(options, formOptions); + + return function transcludeTemplate(template) { + if (!wrapper.length) { + return $q.when(template); + } + + wrapper.forEach(function (aWrapper) { + formlyUsability.checkWrapper(aWrapper, options); + runApiCheck(aWrapper, options); + }); + var promises = wrapper.map(function (w) { + return getTemplate(w.template || w.templateUrl, !w.template); + }); + return $q.all(promises).then(function (wrappersTemplates) { + wrappersTemplates.forEach(function (wrapperTemplate, index) { + formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index]); + }); + wrappersTemplates.reverse(); // wrapper 0 is wrapped in wrapper 1 and so on... + var totalWrapper = wrappersTemplates.shift(); + wrappersTemplates.forEach(function (wrapperTemplate) { + totalWrapper = doTransclusion(totalWrapper, wrapperTemplate); + }); + return doTransclusion(totalWrapper, template); + }); + }; + } + + function doTransclusion(wrapper, template) { + var superWrapper = _angularFix2['default'].element(''); // this allows people not have to have a single root in wrappers + superWrapper.append(wrapper); + var transcludeEl = superWrapper.find('formly-transclude'); + if (!transcludeEl.length) { + // try it using our custom find function + transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude'); + } + transcludeEl.replaceWith(template); + return superWrapper.html(); + } + + function getWrapperOption(options, formOptions) { + /* eslint complexity:[2, 6] */ + var wrapper = options.wrapper; + // explicit null means no wrapper + if (wrapper === null) { + return []; + } + + // nothing specified means use the default wrapper for the type + if (!wrapper) { + // get all wrappers that specify they apply to this type + wrapper = arrayify(formlyConfig.getWrapperByType(options.type)); + } else { + wrapper = arrayify(wrapper).map(formlyConfig.getWrapper); + } + + // get all wrappers for that the type specified that it uses. + var type = formlyConfig.getType(options.type, true, options); + if (type && type.wrapper) { + var typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper); + wrapper = wrapper.concat(typeWrappers); + } + + // add form wrappers + if (formOptions.wrapper) { + var formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper); + wrapper = wrapper.concat(formWrappers); + } + + // add the default wrapper last + var defaultWrapper = formlyConfig.getWrapper(); + if (defaultWrapper) { + wrapper.push(defaultWrapper); + } + return wrapper; + } + + function checkApi(options) { + formlyApiCheck['throw'](formlyApiCheck.formlyFieldOptions, options, { + prefix: 'formly-field directive', + url: 'formly-field-directive-validation-failed' + }); + // validate with the type + var type = options.type && formlyConfig.getType(options.type); + if (type) { + runApiCheck(type, options, true); + } + if (options.expressionProperties && options.expressionProperties.hide) { + formlyWarn('dont-use-expressionproperties.hide-use-hideexpression-instead', 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead', options); + } + } + + function checkFieldGroupApi(options) { + formlyApiCheck['throw'](formlyApiCheck.fieldGroup, options, { + prefix: 'formly-field directive', + url: 'formly-field-directive-validation-failed' + }); + } + + function runApiCheck(_ref2, options, forType) { + var apiCheck = _ref2.apiCheck; + var apiCheckInstance = _ref2.apiCheckInstance; + var apiCheckFunction = _ref2.apiCheckFunction; + var apiCheckOptions = _ref2.apiCheckOptions; + + runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options); + if (forType && options.type) { + _angularFix2['default'].forEach(formlyConfig.getTypeHeritage(options.type), function (type) { + runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options); + }); + } + } + + function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) { + /* eslint complexity:[2, 9] */ + if (!apiCheck) { + return; + } + var instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck; + if (instance.config.disabled || _apiCheck2['default'].globalConfig.disabled) { + return; + } + var fn = apiCheckFunction || 'warn'; + // this is the new API + var checkerObjects = apiCheck(instance); + _angularFix2['default'].forEach(checkerObjects, function (shape, name) { + var checker = instance.shape(shape); + var checkOptions = _angularFix2['default'].extend({ + prefix: 'formly-field type ' + options.type + ' for property ' + name, + url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed' + }, apiCheckOptions); + instance[fn](checker, options[name], checkOptions); + }); + } + } + + // Stateless util functions + function getDefaultOptionsOptionsTypes(type) { + return getDefaultOptionsProperty(type, 'optionsTypes', []); + } + + function getDefaultOptionsProperty(type, prop, defaultValue) { + return type.defaultOptions && type.defaultOptions[prop] || defaultValue; + } + module.exports = exports['default']; + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + + 'use strict'; + + formlyFocus.$inject = ["$timeout", "$document"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + exports['default'] = formlyFocus; + + // @ngInject + function formlyFocus($timeout, $document) { + return { + restrict: 'A', + link: function formlyFocusLink(scope, element, attrs) { + var previousEl = null; + var el = element[0]; + var doc = $document[0]; + attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) { + /* eslint no-bitwise:0 */ // I know what I'm doing. I promise... + if (value === 'true') { + $timeout(function setElementFocus() { + previousEl = doc.activeElement; + el.focus(); + }, ~ ~attrs.focusWait); + } else if (value === 'false') { + if (doc.activeElement === el) { + el.blur(); + if (attrs.hasOwnProperty('refocus') && previousEl) { + previousEl.focus(); + } + } + } + }); + } + }; + } + module.exports = exports['default']; + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + formlyForm.$inject = ["formlyUsability", "formlyWarn", "$parse", "formlyConfig", "$interpolate"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + var _slice = Array.prototype.slice; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + exports['default'] = formlyForm; + + /** + * @ngdoc directive + * @name formlyForm + * @restrict AE + */ + // @ngInject + function formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) { + FormlyFormController.$inject = ["$scope", "formlyApiCheck", "formlyUtil"]; + var currentFormId = 1; + return { + restrict: 'AE', + template: formlyFormGetTemplate, + replace: true, + transclude: true, + scope: { + fields: '=', + model: '=', + form: '=?', + options: '=?' + }, + controller: FormlyFormController, + link: formlyFormLink + }; + + function formlyFormGetTemplate(el, attrs) { + var rootEl = getRootEl(); + var fieldRootEl = getFieldRootEl(); + var formId = 'formly_' + currentFormId++; + var parentFormAttributes = ''; + if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) { + parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes); + } + return '\n <' + rootEl + ' class="formly"\n name="' + getFormName() + '"\n role="form" ' + parentFormAttributes + '>\n <' + fieldRootEl + ' formly-field\n ng-repeat="field in fields ' + getTrackBy() + '"\n ' + getHideDirective() + '="!field.hide"\n class="formly-field"\n options="field"\n model="field.model || model"\n original-model="model"\n fields="fields"\n form="theFormlyForm"\n form-id="' + getFormName() + '"\n form-state="options.formState"\n form-options="options"\n index="$index">\n \n
\n \n '; + + function getRootEl() { + return attrs.rootEl || 'ng-form'; + } + + function getFieldRootEl() { + return attrs.fieldRootEl || 'div'; + } + + function getHideDirective() { + return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if'; + } + + function getTrackBy() { + if (!attrs.trackBy) { + return ''; + } else { + return 'track by ' + attrs.trackBy; + } + } + + function getFormName() { + var formName = formId; + var bindName = attrs.bindName; + if (bindName) { + if (_angularFix2['default'].version.minor < 3) { + throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3'); + } + // we can do a one-time binding here because we know we're in 1.3.x territory + formName = $interpolate.startSymbol() + '::\'formly_\' + ' + bindName + $interpolate.endSymbol(); + } + return formName; + } + + function getTranscludeClass() { + return attrs.transcludeClass || ''; + } + + function copyAttributes(attributes) { + var excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class', 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name']; + var arrayAttrs = []; + _angularFix2['default'].forEach(attributes, function (_ref) { + var nodeName = _ref.nodeName; + var value = _ref.value; + + if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) { + arrayAttrs.push(toKebabCase(nodeName) + '="' + value + '"'); + } + }); + return arrayAttrs.join(' '); + } + } + + // @ngInject + function FormlyFormController($scope, formlyApiCheck, formlyUtil) { + setupOptions(); + $scope.model = $scope.model || {}; + setupFields(); + + // watch the model and evaluate watch expressions that depend on it. + if (!$scope.options.manualModelWatcher) { + $scope.$watch('model', onModelOrFormStateChange, true); + } else if (_angularFix2['default'].isFunction($scope.options.manualModelWatcher)) { + $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true); + } + + if ($scope.options.formState) { + $scope.$watch('options.formState', onModelOrFormStateChange, true); + } + + function onModelOrFormStateChange() { + _angularFix2['default'].forEach($scope.fields, runFieldExpressionProperties); + } + + function validateFormControl(formControl, promise) { + var validate = formControl.$validate; + if (promise) { + promise.then(validate); + } else { + validate(); + } + } + + function runFieldExpressionProperties(field, index) { + var model = field.model || $scope.model; + var promise = field.runExpressions && field.runExpressions(); + if (field.hideExpression) { + // can't use hide with expressionProperties reliably + var val = model[field.key]; + field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model }); + } + if (field.extras && field.extras.validateOnModelChange && field.formControl) { + if (_angularFix2['default'].isArray(field.formControl)) { + _angularFix2['default'].forEach(field.formControl, function (formControl) { + validateFormControl(formControl, promise); + }); + } else { + validateFormControl(field.formControl, promise); + } + } + } + + function setupFields() { + $scope.fields = $scope.fields || []; + + checkDeprecatedOptions($scope.options); + + var fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform; + + if (!_angularFix2['default'].isArray(fieldTransforms)) { + fieldTransforms = [fieldTransforms]; + } + + _angularFix2['default'].forEach(fieldTransforms, function transformFields(fieldTransform) { + if (fieldTransform) { + $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form); + if (!$scope.fields) { + throw formlyUsability.getFormlyError('fieldTransform must return an array of fields'); + } + } + }); + + setupModels(); + + if ($scope.options.watchAllExpressions) { + _angularFix2['default'].forEach($scope.fields, setupHideExpressionWatcher); + } + + _angularFix2['default'].forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified + _angularFix2['default'].forEach($scope.fields, setupWatchers); // setup watchers for all fields + } + + function checkDeprecatedOptions(options) { + if (formlyConfig.extras.fieldTransform && _angularFix2['default'].isFunction(formlyConfig.extras.fieldTransform)) { + formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for formlyConfig.extras: ' + formlyConfig.extras.fieldTransform.name, formlyConfig.extras); + } else if (options.fieldTransform && _angularFix2['default'].isFunction(options.fieldTransform)) { + formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for form', options); + } + } + + function setupOptions() { + formlyApiCheck['throw']([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: 'formly-form options check' }); + $scope.options = $scope.options || {}; + $scope.options.formState = $scope.options.formState || {}; + + _angularFix2['default'].extend($scope.options, { + updateInitialValue: updateInitialValue, + resetModel: resetModel + }); + } + + function updateInitialValue() { + _angularFix2['default'].forEach($scope.fields, function (field) { + if (isFieldGroup(field) && field.options) { + field.options.updateInitialValue(); + } else { + field.updateInitialValue(); + } + }); + } + + function resetModel() { + _angularFix2['default'].forEach($scope.fields, function (field) { + if (isFieldGroup(field) && field.options) { + field.options.resetModel(); + } else if (field.resetModel) { + field.resetModel(); + } + }); + } + + function setupModels() { + // a set of field models that are already watched (the $scope.model will have its own watcher) + var watchedModels = [$scope.model]; + // we will not set up automatic model watchers if manual mode is set + var manualModelWatcher = $scope.options.manualModelWatcher; + + if ($scope.options.formState) { + // $scope.options.formState will have its own watcher + watchedModels.push($scope.options.formState); + } + + _angularFix2['default'].forEach($scope.fields, function (field) { + var isNewModel = initModel(field); + + if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) { + $scope.$watch(function () { + return field.model; + }, onModelOrFormStateChange, true); + watchedModels.push(field.model); + } + }); + } + + function setupHideExpressionWatcher(field, index) { + if (field.hideExpression) { + (function () { + // can't use hide with expressionProperties reliably + var model = field.model || $scope.model; + $scope.$watch(function hideExpressionWatcher() { + var val = model[field.key]; + return evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model }); + }, function (hide) { + return field.hide = hide; + }, true); + })(); + } + } + + function initModel(field) { + var isNewModel = true; + + if (_angularFix2['default'].isString(field.model)) { + (function () { + var expression = field.model; + + isNewModel = !referencesCurrentlyWatchedModel(expression); + + field.model = resolveStringModel(expression); + + $scope.$watch(function () { + return resolveStringModel(expression); + }, function (model) { + return field.model = model; + }); + })(); + } + + return isNewModel; + + function resolveStringModel(expression) { + var index = $scope.fields.indexOf(field); + var model = evalCloseToFormlyExpression(expression, undefined, field, index, { model: $scope.model }); + + if (!model) { + throw formlyUsability.getFieldError('field-model-must-be-initialized', 'Field model must be initialized. When specifying a model as a string for a field, the result of the' + ' expression must have been initialized ahead of time.', field); + } + + return model; + } + } + + function referencesCurrentlyWatchedModel(expression) { + return ['model', 'formState'].some(function (item) { + return formlyUtil.startsWith(expression, item + '.') || formlyUtil.startsWith(expression, item + '['); + }); + } + + function attachKey(field, index) { + if (!isFieldGroup(field)) { + field.key = field.key || index || 0; + } + } + + function setupWatchers(field, index) { + if (!_angularFix2['default'].isDefined(field.watcher)) { + return; + } + var watchers = field.watcher; + if (!_angularFix2['default'].isArray(watchers)) { + watchers = [watchers]; + } + _angularFix2['default'].forEach(watchers, function setupWatcher(watcher) { + if (!_angularFix2['default'].isDefined(watcher.listener) && !watcher.runFieldExpressions) { + throw formlyUsability.getFieldError('all-field-watchers-must-have-a-listener', 'All field watchers must have a listener', field); + } + var watchExpression = getWatchExpression(watcher, field, index); + var watchListener = getWatchListener(watcher, field, index); + + var type = watcher.type || '$watch'; + watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep); + }); + } + + function getWatchExpression(watcher, field, index) { + var watchExpression = undefined; + if (!_angularFix2['default'].isUndefined(watcher.expression)) { + watchExpression = watcher.expression; + } else if (field.key) { + watchExpression = 'model[\'' + field.key.toString().split('.').join('\'][\'') + '\']'; + } + if (_angularFix2['default'].isFunction(watchExpression)) { + (function () { + // wrap the field's watch expression so we can call it with the field as the first arg + // and the stop function as the last arg as a helper + var originalExpression = watchExpression; + watchExpression = function formlyWatchExpression() { + var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments))); + return originalExpression.apply(undefined, _toConsumableArray(args)); + }; + watchExpression.displayName = 'Formly Watch Expression for field for ' + field.key; + })(); + } else if (field.model) { + watchExpression = $parse(watchExpression).bind(null, $scope, { model: field.model }); + } + return watchExpression; + } + + function getWatchListener(watcher, field, index) { + var watchListener = watcher.listener; + if (_angularFix2['default'].isFunction(watchListener) || watcher.runFieldExpressions) { + (function () { + // wrap the field's watch listener so we can call it with the field as the first arg + // and the stop function as the last arg as a helper + var originalListener = watchListener; + watchListener = function formlyWatchListener() { + var value = undefined; + if (originalListener) { + var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments))); + value = originalListener.apply(undefined, _toConsumableArray(args)); + } + if (watcher.runFieldExpressions) { + runFieldExpressionProperties(field, index); + } + return value; + }; + watchListener.displayName = 'Formly Watch Listener for field for ' + field.key; + })(); + } + return watchListener; + } + + function modifyArgs(watcher, index) { + for (var _len = arguments.length, originalArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + originalArgs[_key - 2] = arguments[_key]; + } + + return [$scope.fields[index]].concat(originalArgs, [watcher.stopWatching]); + } + + function evalCloseToFormlyExpression(expression, val, field, index) { + var extraLocals = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4]; + + extraLocals = _angularFix2['default'].extend(getFormlyFieldLikeLocals(field, index), extraLocals); + return formlyUtil.formlyEval($scope, expression, val, val, extraLocals); + } + + function getFormlyFieldLikeLocals(field, index) { + // this makes it closer to what a regular formlyExpression would be + return { + model: field.model, + options: field, + index: index, + formState: $scope.options.formState, + originalModel: $scope.model, + formOptions: $scope.options, + formId: $scope.formId + }; + } + } + + function formlyFormLink(scope, el, attrs) { + setFormController(); + fixChromeAutocomplete(); + + function setFormController() { + var formId = attrs.name; + scope.formId = formId; + scope.theFormlyForm = scope[formId]; + if (attrs.form) { + var getter = $parse(attrs.form); + var setter = getter.assign; + var parentForm = getter(scope.$parent); + if (parentForm) { + scope.theFormlyForm = parentForm; + if (scope[formId]) { + scope.theFormlyForm.$removeControl(scope[formId]); + } + + // this next line is probably one of the more dangerous things that angular-formly does to improve the + // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be + // attached to the form that is passed to formly-form rather than the one that formly-form creates + // this is necessary because it's confusing to have a step between the form you pass in + // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down + // to children forms :-( This line was added to solve this issue: + // https://github.com/formly-js/angular-formly/issues/287 + // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0 + // so I expect it will remain this way for the life of angular 1.x + el.removeData('$formController'); + } else { + setter(scope.$parent, scope[formId]); + } + } + if (!scope.theFormlyForm && !formlyConfig.disableWarnings) { + /* eslint no-console:0 */ + formlyWarn('formly-form-has-no-formcontroller', 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work', el, scope); + } + } + + /* + * chrome autocomplete lameness + * see https://code.google.com/p/chromium/issues/detail?id=468153#c14 + * ლ(ಠ益ಠლ) (╯°□°)╯︵ ┻━┻ (◞‸◟；) + */ + function fixChromeAutocomplete() { + var global = formlyConfig.extras.removeChromeAutoComplete === true; + var offInstance = scope.options && scope.options.removeChromeAutoComplete === false; + var onInstance = scope.options && scope.options.removeChromeAutoComplete === true; + if (global && !offInstance || onInstance) { + var input = document.createElement('input'); + input.setAttribute('autocomplete', 'address-level4'); + input.setAttribute('hidden', 'true'); + el[0].appendChild(input); + } + } + } + + // stateless util functions + function toKebabCase(string) { + if (string) { + return string.replace(/([A-Z])/g, function ($1) { + return '-' + $1.toLowerCase(); + }); + } else { + return ''; + } + } + + function isFieldGroup(field) { + return field && !!field.fieldGroup; + } + } + module.exports = exports['default']; + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + addFormlyNgModelAttrsManipulator.$inject = ["formlyConfig", "$interpolate"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + var _otherUtils = __webpack_require__(9); + + exports['default'] = addFormlyNgModelAttrsManipulator; + + // @ngInject + function addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) { + if (formlyConfig.extras.disableNgModelAttrsManipulator) { + return; + } + formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator); + + function ngModelAttrsManipulator(template, options, scope) { + var node = document.createElement('div'); + var skip = options.extras && options.extras.skipNgModelAttrsManipulator; + if (skip === true) { + return template; + } + node.innerHTML = template; + + var modelNodes = getNgModelNodes(node, skip); + if (!modelNodes || !modelNodes.length) { + return template; + } + + addIfNotPresent(modelNodes, 'id', scope.id); + addIfNotPresent(modelNodes, 'name', scope.name || scope.id); + + addValidation(); + alterNgModelAttr(); + addModelOptions(); + addTemplateOptionsAttrs(); + addNgModelElAttrs(); + + return node.innerHTML; + + function addValidation() { + if (_angularFix2['default'].isDefined(options.validators) || _angularFix2['default'].isDefined(options.validation.messages)) { + addIfNotPresent(modelNodes, 'formly-custom-validation', ''); + } + } + + function alterNgModelAttr() { + if (isPropertyAccessor(options.key)) { + addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key); + } + } + + function addModelOptions() { + if (_angularFix2['default'].isDefined(options.modelOptions)) { + addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions'); + if (options.modelOptions.getterSetter) { + addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value'); + } + } + } + + function addTemplateOptionsAttrs() { + if (!options.templateOptions && !options.expressionProperties) { + // no need to run these if there are no templateOptions or expressionProperties + return; + } + var to = options.templateOptions || {}; + var ep = options.expressionProperties || {}; + + var ngModelAttributes = getBuiltInAttributes(); + + // extend with the user's specifications winning + _angularFix2['default'].extend(ngModelAttributes, options.ngModelAttrs); + + // Feel free to make this more simple :-) + _angularFix2['default'].forEach(ngModelAttributes, function (val, name) { + /* eslint complexity:[2, 14] */ + var attrVal = undefined, + attrName = undefined; + var ref = 'options.templateOptions[\'' + name + '\']'; + var toVal = to[name]; + var epVal = getEpValue(ep, name); + + var inTo = _angularFix2['default'].isDefined(toVal); + var inEp = _angularFix2['default'].isDefined(epVal); + if (val.value) { + // I realize this looks backwards, but it's right, trust me... + attrName = val.value; + attrVal = name; + } else if (val.statement && inTo) { + attrName = val.statement; + if (_angularFix2['default'].isString(to[name])) { + attrVal = '$eval(' + ref + ')'; + } else if (_angularFix2['default'].isFunction(to[name])) { + attrVal = ref + '(model[options.key], options, this, $event)'; + } else { + throw new Error('options.templateOptions.' + name + ' must be a string or function: ' + JSON.stringify(options)); + } + } else if (val.bound && inEp) { + attrName = val.bound; + attrVal = ref; + } else if ((val.attribute || val.boolean) && inEp) { + attrName = val.attribute || val.boolean; + attrVal = '' + $interpolate.startSymbol() + ref + $interpolate.endSymbol(); + } else if (val.attribute && inTo) { + attrName = val.attribute; + attrVal = toVal; + } else if (val.boolean) { + if (inTo && !inEp && toVal) { + attrName = val.boolean; + attrVal = true; + } else { + /* eslint no-empty:0 */ + // empty to illustrate that a boolean will not be added via val.bound + // if you want it added via val.bound, then put it in expressionProperties + } + } else if (val.bound && inTo) { + attrName = val.bound; + attrVal = ref; + } + + if (_angularFix2['default'].isDefined(attrName) && _angularFix2['default'].isDefined(attrVal)) { + addIfNotPresent(modelNodes, attrName, attrVal); + } + }); + } + + function addNgModelElAttrs() { + _angularFix2['default'].forEach(options.ngModelElAttrs, function (val, name) { + addRegardlessOfPresence(modelNodes, name, val); + }); + } + } + + // Utility functions + function getNgModelNodes(node, skip) { + var selectorNot = _angularFix2['default'].isString(skip) ? ':not(' + skip + ')' : ''; + var skipNot = ':not([formly-skip-ng-model-attrs-manipulator])'; + var query = '[ng-model]' + selectorNot + skipNot + ', [data-ng-model]' + selectorNot + skipNot; + try { + return node.querySelectorAll(query); + } catch (e) { + //this code is needed for IE8, as it does not support the CSS3 ':not' selector + //it should be removed when IE8 support is dropped + return getNgModelNodesFallback(node, skip); + } + } + + function getNgModelNodesFallback(node, skip) { + var allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]'); + var matchingNgModelNodes = []; + + //make sure this array is compatible with NodeList type by adding an 'item' function + matchingNgModelNodes.item = function (i) { + return this[i]; + }; + + for (var i = 0; i < allNgModelNodes.length; i++) { + var ngModelNode = allNgModelNodes[i]; + if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') && !(_angularFix2['default'].isString(skip) && nodeMatches(ngModelNode, skip))) { + matchingNgModelNodes.push(ngModelNode); + } + } + + return matchingNgModelNodes; + } + + function nodeMatches(node, selector) { + var div = document.createElement('div'); + div.innerHTML = node.outerHTML; + return div.querySelector(selector); + } + + function getBuiltInAttributes() { + var ngModelAttributes = { + focus: { + attribute: 'formly-focus' + } + }; + var boundOnly = []; + var bothBooleanAndBound = ['required', 'disabled']; + var bothAttributeAndBound = ['pattern', 'minlength']; + var statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur']; + var attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type']; + if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) { + bothAttributeAndBound.push('maxlength'); + } else { + boundOnly.push('maxlength'); + } + + _angularFix2['default'].forEach(boundOnly, function (item) { + ngModelAttributes[item] = { bound: 'ng-' + item }; + }); + + _angularFix2['default'].forEach(bothBooleanAndBound, function (item) { + ngModelAttributes[item] = { boolean: item, bound: 'ng-' + item }; + }); + + _angularFix2['default'].forEach(bothAttributeAndBound, function (item) { + ngModelAttributes[item] = { attribute: item, bound: 'ng-' + item }; + }); + + _angularFix2['default'].forEach(statementOnly, function (item) { + var propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1); + ngModelAttributes[propName] = { statement: 'ng-' + item }; + }); + + _angularFix2['default'].forEach(attributeOnly, function (item) { + ngModelAttributes[item] = { attribute: item }; + }); + return ngModelAttributes; + } + + function getEpValue(ep, name) { + return ep['templateOptions.' + name] || ep['templateOptions[\'' + name + '\']'] || ep['templateOptions["' + name + '"]']; + } + + function addIfNotPresent(nodes, attr, val) { + _angularFix2['default'].forEach(nodes, function (node) { + if (!node.getAttribute(attr)) { + node.setAttribute(attr, val); + } + }); + } + + function addRegardlessOfPresence(nodes, attr, val) { + _angularFix2['default'].forEach(nodes, function (node) { + node.setAttribute(attr, val); + }); + } + + function isPropertyAccessor(key) { + return (0, _otherUtils.contains)(key, '.') || (0, _otherUtils.contains)(key, '[') && (0, _otherUtils.contains)(key, ']'); + } + } + module.exports = exports['default']; + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + addCustomTags.$inject = ["$document"]; + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _angularFix = __webpack_require__(2); + + var _angularFix2 = _interopRequireDefault(_angularFix); + + exports['default'] = addCustomTags; + + // @ngInject + function addCustomTags($document) { + // IE8 check -> + // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx + if ($document && $document.documentMode < 9) { + (function () { + var document = $document.get(0); + // add the custom elements that we need for formly + var customElements = ['formly-field', 'formly-form']; + _angularFix2['default'].forEach(customElements, function (el) { + document.createElement(el); + }); + })(); + } + } + module.exports = exports['default']; + +/***/ } +/******/ ]) +}); +; \ No newline at end of file diff --git a/dist/formly.min.js b/dist/formly.min.js new file mode 100644 index 00000000..5ade5273 --- /dev/null +++ b/dist/formly.min.js @@ -0,0 +1,4 @@ +/*! angular-formly v8.1.0 | MIT | built with ♥ by Astrism , Kent C. Dodds (ó ì_í)=óò=(ì_í ò) */ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("api-check"),require("angular")):"function"==typeof define&&define.amd?define(["api-check","angular"],t):"object"==typeof exports?exports.ngFormly=t(require("api-check"),require("angular")):e.ngFormly=t(e.apiCheck,e.angular)}(this,function(e,t){return function(e){function t(n){if(o[n])return o[n].exports;var r=o[n]={exports:{},id:n,loaded:!1};return e[n].call(r.exports,r,r.exports,t),r.loaded=!0,r.exports}var o={};return t.m=e,t.c=o,t.p="",t(0)}([function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}Object.defineProperty(t,"__esModule",{value:!0});var r=o(9),i=n(r);t["default"]=i["default"],e.exports=t["default"]},function(e,t,o){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=o(18);n.version||(n=window.angular),t["default"]=n,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){return i(e,".")||i(e,"[")&&i(e,"]")}function i(e,t){return e&&e.indexOf?-1!==e.indexOf(t):!1}function a(e,t,o,n,r){return v["default"].isFunction(t)?t(n,o,e,r):e.$eval(t,v["default"].extend({$viewValue:n,$modelValue:o},r))}function l(e,t,o){if(t.id)return t.id;var n=t.type;return!n&&t.template?n="template":!n&&t.templateUrl&&(n="templateUrl"),[e,n,t.key,o].join("_")}function f(e){return v["default"].forEach(arguments,function(t,o){o&&v["default"].forEach(t,function(t,o){v["default"].isDefined(e[o])?s(e[o],t)&&f(e[o],t):e[o]=v["default"].copy(t)})}),e}function s(e,t){return v["default"].isObject(e)&&v["default"].isObject(t)&&Object.getPrototypeOf(e)===Object.getPrototypeOf(t)}function u(e,t){if(e.prop||(e=v["default"].element(e)),e.prop("nodeName")===t.toUpperCase())return e;for(var o=e.children(),n=0;o&&no;o++)t[o]=arguments[o];return function(){var e=arguments;t.forEach(function(t){return t.apply(null,e)})}}function c(e,t,o){return o&&(e=e[o],t=t[o]),t&&e?(v["default"].forEach(t,function(t){-1===e.indexOf(t)&&e.push(t)}),e):t?t:e}function m(e,t){return v["default"].isString(e)&&v["default"].isString(t)?e.length>=t.length&&e.substring(0,t.length)===t:!1}function y(e,t){return v["default"].isString(e)&&v["default"].isString(t)?e.length>=t.length&&-1!==e.indexOf(t):!1}Object.defineProperty(t,"__esModule",{value:!0});var h=o(1),v=n(h);t["default"]={containsSelector:r,containsSpecialChar:i,formlyEval:a,getFieldId:l,reverseDeepMerge:f,findByNodeName:u,arrayify:p,extendFunction:d,extendArray:c,startsWith:m,contains:y},e.exports=t["default"]},function(e,t,o){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t["default"]="https://github.com/formly-js/angular-formly/blob/8.1.0/other/ERRORS_AND_WARNINGS.md#",e.exports=t["default"]},function(t,o){t.exports=e},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){return{restrict:"A",require:"ngModel",link:function(t,o,n,r){function i(e,t,o){l(t,o),t=a["default"].isObject(t)?t.expression:t,p?f(t,o,e):s(t,o,e)}function l(o,n){var i=o.message;i&&(u.validation.messages[n]=function(){return e.formlyEval(t,i,r.$modelValue,r.$viewValue)})}function f(o,n,i){var a=i?"$asyncValidators":"$validators";r[a][n]=function(n,r){return e.formlyEval(t,o,n,r)}}function s(o,n,i){var a=void 0;r.$parsers.unshift(function(l){var f=e.formlyEval(t,o,r.$modelValue,l);return i?(r.$pending=r.$pending||{},r.$pending[n]=!0,a=f,f.then(function(){a===f&&r.$setValidity(n,!0)})["catch"](function(){a===f&&r.$setValidity(n,!1)})["finally"](function(){var e=r.$pending||{};1===Object.keys(e).length?delete r.$pending:delete r.$pending[n]})):r.$setValidity(n,f),l})}var u=t.options;u.validation.messages=u.validation.messages||{},a["default"].forEach(u.validation.messages,function(o,n){u.validation.messages[n]=function(){return e.formlyEval(t,o,r.$modelValue,r.$viewValue)}});var p=r.hasOwnProperty("$validators")&&!n.hasOwnProperty("useParsers");a["default"].forEach(u.validators,a["default"].bind(null,i,!1)),a["default"].forEach(u.asyncValidators,a["default"].bind(null,i,!0))}}}r.$inject=["formlyUtil"],Object.defineProperty(t,"__esModule",{value:!0});var i=o(1),a=n(i);t["default"]=r,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){if(Array.isArray(e)){for(var t=0,o=Array(e.length);t\n \n ").then(E(e.options,e.formOptions)).then(w)}function y(){e.options.elementAttributes&&n.attr(e.options.elementAttributes)}function h(){e.options.className&&n.addClass(e.options.className),e.options.type&&n.addClass("formly-field-"+e.options.type)}function w(t){return n.html(v(t)),o(n.contents())(e),t}function $(t){function o(t){var o=/\{\{(.*?)}}/,r=o.exec(t);r&&(t=i(t)(e)),n(t)}function n(t){e.$watch('form["'+t+'"]',function(t){t&&(_>1?(e.options.formControl||(e.options.formControl=[]),e.options.formControl.push(t)):e.options.formControl=t,e.fc=e.options.formControl,y(),u(),p(),c())})}function u(){y=e.$watch(function(){var t=f.extras.errorExistsAndShouldBeVisibleExpression,o=e.options,n=j(e.fc);return n.some(function(e){return e.$invalid})?"boolean"==typeof o.validation.show?o.validation.show:t?n.some(function(o){return d.formlyEval(e,t,o.$modelValue,o.$viewValue)}):n.some(function(e){var t=s["default"].isUndefined(e.$touched)&&e.$dirty;return e.$touched||t}):!1},function(t){e.options.validation.errorExistsAndShouldBeVisible=t,e.showError=t})}function p(){m("parsers")}function c(){m("formatters");var t=e.fc,o=e.form.$pristine;e.options.formatters&&!function(){var n=t.$modelValue;t.$formatters.forEach(function(e){n=e(n)}),t.$setViewValue(n),t.$render(),t.$setPristine(),o&&e.form.$setPristine()}()}function m(t){function o(r){if(!r)return[];s["default"].isString(r)&&(r=f.getType(r,!0,e.options));var i=[];return r["extends"]&&(i=d.extendArray(i,o(r["extends"]))),i=d.extendArray(i,l(r,t,[])),i=d.extendArray(i,n(a(r)))}function n(){var e=arguments.length<=0||void 0===arguments[0]?[]:arguments[0],t=[];return s["default"].forEach(s["default"].copy(j(e)).reverse(),function(e){t=d.extendArray(t,o(e))}),t}function i(t){function o(o){var n=e.options.value();return d.formlyEval(e,t,n,o)}return o[u]=t,o}var u="originalParser";"formatters"===t&&(u="originalFormatter");var p=o(C);p=d.extendArray(p,n(e.options.optionsTypes)),p=d.extendArray(p,e.options[t]),s["default"].forEach(p,function(e,t){p[t]=i(e)});var c=e.fc;s["default"].isArray(c)||(c=[c]),s["default"].forEach(c,function(e){var o;e["$"+t]=(o=e["$"+t]).concat.apply(o,r(p))})}var y=s["default"].noop;if(!e.options.noFormControl){var h=s["default"].element("
"+t+"
"),v=h[0].querySelectorAll("[ng-model],[data-ng-model]");v.length&&s["default"].forEach(v,function(e){_++,o(e.getAttribute("name"))})}}function A(){C&&C.link&&C.link.apply(F,T),e.options.link&&e.options.link.apply(F,T)}function M(o){return function(n){var r=t.when(n);return s["default"].forEach(o,function(o){r=r.then(function(n){return t.when(o(n,e.options,e)).then(function(e){return s["default"].isString(e)?e:v(e)})})}),r}}if(e.options.fieldGroup)return void c();!p&&e.options.model&&e.$watch("options.model",function(){return e.options.runExpressions()},!0),y(),h();var C=g(e.options),T=arguments,F=this,_=0,W=b(e.options,e.formOptions);O(e.options).then(M(W.preWrapper)).then(E(e.options,e.formOptions)).then(M(W.postWrapper)).then(w).then($).then(A)["catch"](function(t){m("there-was-a-problem-setting-the-template-for-this-field","There was a problem setting the template for this field ",e.options,t)})}function v(e){var t=s["default"].element("");return t.append(e).html()}function g(e){return e.type&&f.getType(e.type)}function b(e,t){function o(e){var t=e||{},o=t.preWrapper,i=void 0===o?[]:o,a=t.postWrapper,l=void 0===a?[]:a;n=n.concat(i),r=r.concat(l)}var n=[],r=[];return o(e.templateManipulators),o(t.templateManipulators),o(f.templateManipulators),{preWrapper:n,postWrapper:r}}function O(e){function t(t,o){return s["default"].isDefined(e[t])?e[t]:o&&s["default"].isDefined(o[t])?o[t]:void 0}var o=f.getType(e.type,!0,e),n=t("template",o),r=t("templateUrl",o);if(s["default"].isUndefined(n)&&!r)throw c.getFieldError("type-type-has-no-template","Type '"+e.type+"' has no template. On element:",e);return x(r||n,s["default"].isUndefined(n),e)}function x(o,r,i){var a=void 0;if(a=s["default"].isFunction(o)?t.when(o(i)):t.when(o),!r)return a;var l=function(){var t={cache:n};return{v:a.then(function(o){return e.get(o,t)}).then(function(e){return e.data})["catch"](function(e){m("problem-loading-template-for-templateurl","Problem loading template for "+o,e)})}}();return"object"==typeof l?l.v:void 0}function E(e,o){var n=$(e,o);return function(o){if(!n.length)return t.when(o);n.forEach(function(t){c.checkWrapper(t,e),M(t,e)});var r=n.map(function(e){return x(e.template||e.templateUrl,!e.template)});return t.all(r).then(function(e){e.forEach(function(e,t){c.checkWrapperTemplate(e,n[t])}),e.reverse();var t=e.shift();return e.forEach(function(e){t=w(t,e)}),w(t,o)})}}function w(e,t){var o=s["default"].element("");o.append(e);var n=o.find("formly-transclude");return n.length||(n=d.findByNodeName(o,"formly-transclude")),n.replaceWith(t),o.html()}function $(e,t){var o=e.wrapper;if(null===o)return[];o=o?j(o).map(f.getWrapper):j(f.getWrapperByType(e.type));var n=f.getType(e.type,!0,e);if(n&&n.wrapper){var r=j(n.wrapper).map(f.getWrapper);o=o.concat(r)}if(t.wrapper){var i=j(t.wrapper).map(f.getWrapper);o=o.concat(i)}var a=f.getWrapper();return a&&o.push(a),o}function A(e){u["throw"](u.formlyFieldOptions,e,{prefix:"formly-field directive",url:"formly-field-directive-validation-failed"});var t=e.type&&f.getType(e.type);t&&M(t,e,!0),e.expressionProperties&&e.expressionProperties.hide&&m("dont-use-expressionproperties.hide-use-hideexpression-instead","You have specified `hide` in `expressionProperties`. Use `hideExpression` instead",e)}function k(e){u["throw"](u.fieldGroup,e,{prefix:"formly-field directive",url:"formly-field-directive-validation-failed"})}function M(e,t,o){var n=e.apiCheck,r=e.apiCheckInstance,i=e.apiCheckFunction,a=e.apiCheckOptions;C(n,r,i,a,t),o&&t.type&&s["default"].forEach(f.getTypeHeritage(t.type),function(e){C(e.apiCheck,e.apiCheckInstance,e.apiCheckFunction,e.apiCheckOptions,t)})}function C(e,t,o,n,r){if(e){var i=t||f.extras.apiCheckInstance||u;if(!i.config.disabled&&!p["default"].globalConfig.disabled){var a=o||"warn",l=e(i);s["default"].forEach(l,function(e,t){var o=i.shape(e),l=s["default"].extend({prefix:"formly-field type "+r.type+" for property "+t,url:u.config.output.docsBaseUrl+"formly-field-type-apicheck-failed"},n);i[a](o,r[t],l)})}}}y.$inject=["$scope","$timeout","$parse","$controller","formlyValidationMessages"];var j=d.arrayify;return{restrict:"AE",transclude:!0,require:"?^formlyForm",scope:{options:"=",model:"=",originalModel:"=?",formId:"@",index:"=?",fields:"=?",formState:"=?",formOptions:"=?",form:"=?"},controller:y,link:h}}function a(e){return l(e,"optionsTypes",[])}function l(e,t,o){return e.defaultOptions&&e.defaultOptions[t]||o}i.$inject=["$http","$q","$compile","$templateCache","$interpolate","formlyConfig","formlyApiCheck","formlyUtil","formlyUsability","formlyWarn"],Object.defineProperty(t,"__esModule",{value:!0});var f=o(1),s=n(f),u=o(4),p=n(u);t["default"]=i,e.exports=t["default"]},function(e,t){"use strict";function o(e,t){return{restrict:"A",link:function(o,n,r){var i=null,a=n[0],l=t[0];r.$observe("formlyFocus",function(t){"true"===t?e(function(){i=l.activeElement,a.focus()},~~r.focusWait):"false"===t&&l.activeElement===a&&(a.blur(),r.hasOwnProperty("refocus")&&i&&i.focus())})}}}o.$inject=["$timeout","$document"],Object.defineProperty(t,"__esModule",{value:!0}),t["default"]=o,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){if(Array.isArray(e)){for(var t=0,o=Array(e.length);t\n <"+h+' formly-field\n ng-repeat="field in fields '+s()+'"\n '+l()+'="!field.hide"\n class="formly-field"\n options="field"\n model="field.model || model"\n original-model="model"\n fields="fields"\n form="theFormlyForm"\n form-id="'+u()+'"\n form-state="options.formState"\n form-options="options"\n index="$index">\n \n
\n \n "}function s(i,l,s){function u(){f["default"].forEach(i.fields,c)}function p(e,t){var o=e.$validate;t?t.then(o):o()}function c(e,t){var o=e.model||i.model,n=e.runExpressions&&e.runExpressions();if(e.hideExpression){var r=o[e.key];e.hide=C(e.hideExpression,r,e,t,{model:o})}e.extras&&e.extras.validateOnModelChange&&e.formControl&&(f["default"].isArray(e.formControl)?f["default"].forEach(e.formControl,function(e){p(e,n)}):p(e.formControl,n))}function m(){i.fields=i.fields||[],y(i.options);var t=i.options.fieldTransform||n.extras.fieldTransform;f["default"].isArray(t)||(t=[t]),f["default"].forEach(t,function(t){if(t&&(i.fields=t(i.fields,i.model,i.options,i.form),!i.fields))throw e.getFormlyError("fieldTransform must return an array of fields")}),b(),i.options.watchAllExpressions&&f["default"].forEach(i.fields,O),f["default"].forEach(i.fields,w),f["default"].forEach(i.fields,$)}function y(e){n.extras.fieldTransform&&f["default"].isFunction(n.extras.fieldTransform)?t("fieldtransform-as-a-function-deprecated","fieldTransform as a function has been deprecated.","Attempted for formlyConfig.extras: "+n.extras.fieldTransform.name,n.extras):e.fieldTransform&&f["default"].isFunction(e.fieldTransform)&&t("fieldtransform-as-a-function-deprecated","fieldTransform as a function has been deprecated.","Attempted for form",e)}function h(){l["throw"]([l.formOptionsApi.optional],[i.options],{prefix:"formly-form options check"}),i.options=i.options||{},i.options.formState=i.options.formState||{},f["default"].extend(i.options,{updateInitialValue:v,resetModel:g})}function v(){f["default"].forEach(i.fields,function(e){d(e)&&e.options?e.options.updateInitialValue():e.updateInitialValue()})}function g(){f["default"].forEach(i.fields,function(e){d(e)&&e.options?e.options.resetModel():e.resetModel&&e.resetModel()})}function b(){var e=[i.model],t=i.options.manualModelWatcher;i.options.formState&&e.push(i.options.formState),f["default"].forEach(i.fields,function(o){var n=x(o);o.model&&n&&-1===e.indexOf(o.model)&&!t&&(i.$watch(function(){return o.model},u,!0),e.push(o.model))})}function O(e,t){e.hideExpression&&!function(){var o=e.model||i.model;i.$watch(function(){var n=o[e.key];return C(e.hideExpression,n,e,t,{model:o})},function(t){return e.hide=t},!0)}()}function x(t){function o(o){var n=i.fields.indexOf(t),r=C(o,void 0,t,n,{model:i.model});if(!r)throw e.getFieldError("field-model-must-be-initialized","Field model must be initialized. When specifying a model as a string for a field, the result of the expression must have been initialized ahead of time.",t);return r}var n=!0;return f["default"].isString(t.model)&&!function(){var e=t.model;n=!E(e),t.model=o(e),i.$watch(function(){return o(e)},function(e){return t.model=e})}(),n}function E(e){return["model","formState"].some(function(t){return s.startsWith(e,t+".")||s.startsWith(e,t+"[")})}function w(e,t){d(e)||(e.key=e.key||t||0)}function $(t,o){if(f["default"].isDefined(t.watcher)){var n=t.watcher;f["default"].isArray(n)||(n=[n]),f["default"].forEach(n,function(n){if(!f["default"].isDefined(n.listener)&&!n.runFieldExpressions)throw e.getFieldError("all-field-watchers-must-have-a-listener","All field watchers must have a listener",t);var r=A(n,t,o),a=k(n,t,o),l=n.type||"$watch";n.stopWatching=i[l](r,a,n.watchDeep)})}}function A(e,t,n){var l=void 0;return f["default"].isUndefined(e.expression)?t.key&&(l="model['"+t.key.toString().split(".").join("']['")+"']"):l=e.expression,f["default"].isFunction(l)?!function(){var o=l;l=function(){var t=M.apply(void 0,[e,n].concat(a.call(arguments)));return o.apply(void 0,r(t))},l.displayName="Formly Watch Expression for field for "+t.key}():t.model&&(l=o(l).bind(null,i,{model:t.model})),l}function k(e,t,o){var n=e.listener;return(f["default"].isFunction(n)||e.runFieldExpressions)&&!function(){var i=n;n=function(){var n=void 0;if(i){var l=M.apply(void 0,[e,o].concat(a.call(arguments)));n=i.apply(void 0,r(l))}return e.runFieldExpressions&&c(t,o),n},n.displayName="Formly Watch Listener for field for "+t.key}(),n}function M(e,t){for(var o=arguments.length,n=Array(o>2?o-2:0),r=2;o>r;r++)n[r-2]=arguments[r];return[i.fields[t]].concat(n,[e.stopWatching])}function C(e,t,o,n){var r=arguments.length<=4||void 0===arguments[4]?{}:arguments[4];return r=f["default"].extend(j(o,n),r),s.formlyEval(i,e,t,t,r)}function j(e,t){return{model:e.model,options:e,index:t,formState:i.options.formState,originalModel:i.model,formOptions:i.options,formId:i.formId}}h(),i.model=i.model||{},m(),i.options.manualModelWatcher?f["default"].isFunction(i.options.manualModelWatcher)&&i.$watch(i.options.manualModelWatcher,u,!0):i.$watch("model",u,!0),i.options.formState&&i.$watch("options.formState",u,!0)}function u(e,r,i){function a(){var a=i.name;if(e.formId=a,e.theFormlyForm=e[a],i.form){var l=o(i.form),f=l.assign,s=l(e.$parent);s?(e.theFormlyForm=s,e[a]&&e.theFormlyForm.$removeControl(e[a]),r.removeData("$formController")):f(e.$parent,e[a])}e.theFormlyForm||n.disableWarnings||t("formly-form-has-no-formcontroller","Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work",r,e)}function l(){var t=n.extras.removeChromeAutoComplete===!0,o=e.options&&e.options.removeChromeAutoComplete===!1,i=e.options&&e.options.removeChromeAutoComplete===!0;if(t&&!o||i){var a=document.createElement("input");a.setAttribute("autocomplete","address-level4"),a.setAttribute("hidden","true"),r[0].appendChild(a)}}a(),l()}function p(e){return e?e.replace(/([A-Z])/g,function(e){return"-"+e.toLowerCase()}):""}function d(e){return e&&!!e.fieldGroup}s.$inject=["$scope","formlyApiCheck","formlyUtil"];var c=1;return{restrict:"AE",template:l,replace:!0,transclude:!0,scope:{fields:"=",model:"=",form:"=?",options:"=?"},controller:s,link:u}}i.$inject=["formlyUsability","formlyWarn","$parse","formlyConfig","$interpolate"],Object.defineProperty(t,"__esModule",{value:!0});var a=Array.prototype.slice,l=o(1),f=n(l);t["default"]=i,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}Object.defineProperty(t,"__esModule",{value:!0});var r=o(1),i=n(r),a=o(10),l=n(a),f=o(3),s=n(f),u=o(12),p=n(u),d=o(11),c=n(d),m=o(13),y=n(m),h=o(16),v=n(h),g=o(17),b=n(g),O=o(5),x=n(O),E=o(6),w=n(E),$=o(7),A=n($),k=o(8),M=n(k),C=o(15),j=n(C),T=o(14),F=n(T),_="formly";t["default"]=_;var W=i["default"].module(_,[]);W.constant("formlyApiCheck",l["default"]),W.constant("formlyErrorAndWarningsUrlPrefix",s["default"]),W.constant("formlyVersion","8.1.0"),W.provider("formlyUsability",p["default"]),W.provider("formlyConfig",c["default"]),W.factory("formlyValidationMessages",y["default"]),W.factory("formlyUtil",v["default"]),W.factory("formlyWarn",b["default"]),W.directive("formlyCustomValidation",x["default"]),W.directive("formlyField",w["default"]),W.directive("formlyFocus",A["default"]),W.directive("formlyForm",M["default"]),W.run(j["default"]),W.run(F["default"]),e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e,t){function o(o,r,i,a){var l=a&&a.hasOwnProperty(r),f=e.some(function(e){return a&&a.hasOwnProperty(e)});return f||l?l?t(o,r,i,a):void 0:s.utils.getError(r,i,n)}a["default"].isArray(e)||(e=[e]);var n="specified if these are not specified: `"+e.join(", ")+"` (otherwise it's optional)";return o.type=n,s.utils.checkerHelpers.setupChecker(o)}Object.defineProperty(t,"__esModule",{value:!0});var i=o(1),a=n(i),l=o(4),f=n(l),s=(0,f["default"])({output:{prefix:"angular-formly:",docsBaseUrl:o(3)}}),u=s.oneOfType([s.string,s.func]),p=s.typeOrArrayOf(s.string).nullable,d=s.func,c=s.shape.onlyIf("apiCheck",s.func.withProperties({warn:s.func,"throw":s.func,shape:s.func})),m=s.shape.onlyIf("apiCheck",s.oneOf(["throw","warn"])),y=s.shape({name:r("types",s.string).optional,template:s.shape.ifNot("templateUrl",s.string).optional,templateUrl:s.shape.ifNot("template",s.string).optional,types:s.typeOrArrayOf(s.string).optional,overwriteOk:s.bool.optional,apiCheck:d.optional,apiCheckInstance:c.optional,apiCheckFunction:m.optional,apiCheckOptions:s.object.optional}).strict,h=s.objectOf(s.oneOfType([u,s.shape({expression:u,message:u.optional}).strict])),v=s.oneOfType([s.string,s.object]),g=s.shape({preWrapper:s.arrayOf(s.func).nullable.optional,postWrapper:s.arrayOf(s.func).nullable.optional}).strict.nullable,b=s.objectOf(s.oneOfType([u,s.shape({expression:u,message:u.optional}).strict])),O=s.typeOrArrayOf(s.shape({expression:u.optional,listener:u.optional,runFieldExpressions:s.bool.optional})),x={$$hashKey:s.any.optional,type:s.shape.ifNot(["template","templateUrl"],s.string).optional,template:s.shape.ifNot(["type","templateUrl"],s.oneOfType([s.string,s.func])).optional,templateUrl:s.shape.ifNot(["type","template"],s.oneOfType([s.string,s.func])).optional,key:s.oneOfType([s.string,s.number]).optional,model:v.optional,originalModel:v.optional,className:s.string.optional,id:s.string.optional,name:s.string.optional,expressionProperties:h.optional,extras:s.shape({validateOnModelChange:s.bool.optional,skipNgModelAttrsManipulator:s.oneOfType([s.string,s.bool]).optional}).strict.optional,data:s.object.optional,templateOptions:s.object.optional,wrapper:p.optional,modelOptions:s.shape({updateOn:s.string.optional,debounce:s.oneOfType([s.objectOf(s.number),s.number]).optional,allowInvalid:s.bool.optional,getterSetter:s.bool.optional,timezone:s.string.optional}).optional,watcher:O.optional,validators:b.optional,asyncValidators:b.optional,parsers:s.arrayOf(u).optional,formatters:s.arrayOf(u).optional,noFormControl:s.bool.optional,hide:s.bool.optional,hideExpression:u.optional,ngModelElAttrs:s.objectOf(s.string).optional,ngModelAttrs:s.objectOf(s.shape({statement:s.shape.ifNot(["value","attribute","bound","boolean"],s.any).optional,value:s.shape.ifNot("statement",s.any).optional,attribute:s.shape.ifNot("statement",s.any).optional,bound:s.shape.ifNot("statement",s.any).optional,"boolean":s.shape.ifNot("statement",s.any).optional}).strict).optional,elementAttributes:s.objectOf(s.string).optional,optionsTypes:s.typeOrArrayOf(s.string).optional,link:s.func.optional,controller:s.oneOfType([s.string,s.func,s.array]).optional,validation:s.shape({show:s.bool.nullable.optional,messages:s.objectOf(u).optional,errorExistsAndShouldBeVisible:s.bool.optional}).optional,formControl:s.typeOrArrayOf(s.object).optional,value:s.func.optional,runExpressions:s.func.optional,templateManipulators:g.optional,resetModel:s.func.optional,updateInitialValue:s.func.optional,initialValue:s.any.optional,defaultValue:s.any.optional},E=s.shape(x).strict,w=s.shape({formState:s.object.optional,resetModel:s.func.optional,updateInitialValue:s.func.optional,removeChromeAutoComplete:s.bool.optional,templateManipulators:g.optional,manualModelWatcher:s.oneOfType([s.bool,s.func]).optional,watchAllExpressions:s.bool.optional,wrapper:p.optional,fieldTransform:s.oneOfType([s.func,s.array]).optional,data:s.object.optional}).strict,$=s.shape({$$hashKey:s.any.optional,key:s.oneOfType([s.string,s.number]).optional,fieldGroup:s.arrayOf(s.oneOfType([E,s.object])),className:s.string.optional,options:w.optional,templateOptions:s.object.optional,wrapper:p.optional,watcher:O.optional,hide:s.bool.optional,hideExpression:u.optional,data:s.object.optional,model:v.optional,form:s.object.optional,elementAttributes:s.objectOf(s.string).optional}).strict,A=a["default"].copy(x);A.key=s.string.optional;var k=s.shape({name:s.string,template:s.shape.ifNot("templateUrl",s.oneOfType([s.string,s.func])).optional,templateUrl:s.shape.ifNot("template",s.oneOfType([s.string,s.func])).optional,controller:s.oneOfType([s.func,s.string,s.array]).optional,link:s.func.optional,defaultOptions:s.oneOfType([s.func,s.shape(A)]).optional,"extends":s.string.optional,wrapper:p.optional,data:s.object.optional,apiCheck:d.optional,apiCheckInstance:c.optional,apiCheckFunction:m.optional,apiCheckOptions:s.object.optional,overwriteOk:s.bool.optional}).strict;a["default"].extend(s,{formlyTypeOptions:k,formlyFieldOptions:E,formlyExpression:u,formlyWrapperType:y,fieldGroup:$,formOptionsApi:w}),t["default"]=s,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){if(Array.isArray(e)){for(var t=0,o=Array(e.length);t" in it: '+e+"\nAdditional information: "+JSON.stringify(t))}var f=this;a["default"].extend(this,{getFormlyError:n,getFieldError:o,checkWrapper:i,checkWrapperTemplate:l,getErrorMessage:r,$get:function(){return f}})}r.$inject=["formlyApiCheck","formlyErrorAndWarningsUrlPrefix"],Object.defineProperty(t,"__esModule",{value:!0});var i=o(1),a=n(i);t["default"]=r,e.exports=t["default"]},function(e,t){"use strict";function o(){function e(e,t,r,i,a){n.messages[e]=o(t,r,i,a)}function t(e,t){n.messages[e]=function(){return t}}function o(e,t,o,n){return function(r,i,a){return"undefined"!=typeof a.options.templateOptions[e]?t+" "+a.options.templateOptions[e]+" "+o:n}}var n={addTemplateOptionValueMessage:e,addStringMessage:t,messages:{}};return n}Object.defineProperty(t,"__esModule",{value:!0}),t["default"]=o,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e){e&&e.documentMode<9&&!function(){var t=e.get(0),o=["formly-field","formly-form"];a["default"].forEach(o,function(e){t.createElement(e)})}()}r.$inject=["$document"],Object.defineProperty(t,"__esModule",{value:!0});var i=o(1),a=n(i);t["default"]=r,e.exports=t["default"]},function(e,t,o){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}function r(e,t){function o(e,o,r){function i(){(a["default"].isDefined(o.validators)||a["default"].isDefined(o.validation.messages))&&u(g,"formly-custom-validation","")}function l(){d(o.key)&&p(g,"ng-model","model."+o.key)}function c(){a["default"].isDefined(o.modelOptions)&&(u(g,"ng-model-options","options.modelOptions"),o.modelOptions.getterSetter&&p(g,"ng-model","options.value"))}function m(){if(o.templateOptions||o.expressionProperties){var e=o.templateOptions||{},n=o.expressionProperties||{},r=f();a["default"].extend(r,o.ngModelAttrs),a["default"].forEach(r,function(r,i){var l=void 0,f=void 0,p="options.templateOptions['"+i+"']",d=e[i],c=s(n,i),m=a["default"].isDefined(d),y=a["default"].isDefined(c);if(r.value)f=r.value,l=i;else if(r.statement&&m)if(f=r.statement,a["default"].isString(e[i]))l="$eval("+p+")";else{if(!a["default"].isFunction(e[i]))throw new Error("options.templateOptions."+i+" must be a string or function: "+JSON.stringify(o));l=p+"(model[options.key], options, this, $event)"}else r.bound&&y?(f=r.bound,l=p):(r.attribute||r["boolean"])&&y?(f=r.attribute||r["boolean"],l=""+t.startSymbol()+p+t.endSymbol()):r.attribute&&m?(f=r.attribute,l=d):r["boolean"]?m&&!y&&d&&(f=r["boolean"],l=!0):r.bound&&m&&(f=r.bound,l=p);a["default"].isDefined(f)&&a["default"].isDefined(l)&&u(g,f,l)})}}function y(){a["default"].forEach(o.ngModelElAttrs,function(e,t){p(g,t,e)})}var h=document.createElement("div"),v=o.extras&&o.extras.skipNgModelAttrsManipulator;if(v===!0)return e;h.innerHTML=e;var g=n(h,v);return g&&g.length?(u(g,"id",r.id),u(g,"name",r.name||r.id),i(),l(),c(),m(),y(),h.innerHTML):e}function n(e,t){var o=a["default"].isString(t)?":not("+t+")":"",n=":not([formly-skip-ng-model-attrs-manipulator])",i="[ng-model]"+o+n+", [data-ng-model]"+o+n;try{return e.querySelectorAll(i)}catch(l){return r(e,t)}}function r(e,t){var o=e.querySelectorAll("[ng-model], [data-ng-model]"),n=[];n.item=function(e){return this[e]};for(var r=0;r, Kent C. Dodds (ó ì_í)=óò=(ì_í ò) */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"api-check\"), require(\"angular\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"api-check\", \"angular\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ngFormly\"] = factory(require(\"api-check\"), require(\"angular\"));\n\telse\n\t\troot[\"ngFormly\"] = factory(root[\"apiCheck\"], root[\"angular\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_18__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _indexCommon = __webpack_require__(9);\n\t\n\tvar _indexCommon2 = _interopRequireDefault(_indexCommon);\n\t\n\texports['default'] = _indexCommon2['default'];\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 1 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// some versions of angular don't export the angular module properly,\n\t// so we get it from window in this case.\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\tvar angular = __webpack_require__(18);\n\t\n\t/* istanbul ignore next */\n\tif (!angular.version) {\n\t angular = window.angular;\n\t}\n\texports['default'] = angular;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\texports['default'] = {\n\t containsSelector: containsSelector, containsSpecialChar: containsSpecialChar, formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName,\n\t arrayify: arrayify, extendFunction: extendFunction, extendArray: extendArray, startsWith: startsWith, contains: contains\n\t};\n\t\n\tfunction containsSelector(string) {\n\t return containsSpecialChar(string, '.') || containsSpecialChar(string, '[') && containsSpecialChar(string, ']');\n\t}\n\t\n\tfunction containsSpecialChar(a, b) {\n\t if (!a || !a.indexOf) {\n\t return false;\n\t }\n\t return a.indexOf(b) !== -1;\n\t}\n\t\n\tfunction formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {\n\t if (_angularFix2['default'].isFunction(expression)) {\n\t return expression($viewValue, $modelValue, scope, extraLocals);\n\t } else {\n\t return scope.$eval(expression, _angularFix2['default'].extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals));\n\t }\n\t}\n\t\n\tfunction getFieldId(formId, options, index) {\n\t if (options.id) {\n\t return options.id;\n\t }\n\t var type = options.type;\n\t if (!type && options.template) {\n\t type = 'template';\n\t } else if (!type && options.templateUrl) {\n\t type = 'templateUrl';\n\t }\n\t\n\t return [formId, type, options.key, index].join('_');\n\t}\n\t\n\tfunction reverseDeepMerge(dest) {\n\t _angularFix2['default'].forEach(arguments, function (src, index) {\n\t if (!index) {\n\t return;\n\t }\n\t _angularFix2['default'].forEach(src, function (val, prop) {\n\t if (!_angularFix2['default'].isDefined(dest[prop])) {\n\t dest[prop] = _angularFix2['default'].copy(val);\n\t } else if (objAndSameType(dest[prop], val)) {\n\t reverseDeepMerge(dest[prop], val);\n\t }\n\t });\n\t });\n\t return dest;\n\t}\n\t\n\tfunction objAndSameType(obj1, obj2) {\n\t return _angularFix2['default'].isObject(obj1) && _angularFix2['default'].isObject(obj2) && Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2);\n\t}\n\t\n\t// recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8\n\tfunction findByNodeName(el, nodeName) {\n\t if (!el.prop) {\n\t // not a jQuery or jqLite object -> wrap it\n\t el = _angularFix2['default'].element(el);\n\t }\n\t\n\t if (el.prop('nodeName') === nodeName.toUpperCase()) {\n\t return el;\n\t }\n\t\n\t var c = el.children();\n\t for (var i = 0; c && i < c.length; i++) {\n\t var node = findByNodeName(c[i], nodeName);\n\t if (node) {\n\t return node;\n\t }\n\t }\n\t}\n\t\n\tfunction arrayify(obj) {\n\t if (obj && !_angularFix2['default'].isArray(obj)) {\n\t obj = [obj];\n\t } else if (!obj) {\n\t obj = [];\n\t }\n\t return obj;\n\t}\n\t\n\tfunction extendFunction() {\n\t for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {\n\t fns[_key] = arguments[_key];\n\t }\n\t\n\t return function extendedFunction() {\n\t var args = arguments;\n\t fns.forEach(function (fn) {\n\t return fn.apply(null, args);\n\t });\n\t };\n\t}\n\t\n\tfunction extendArray(primary, secondary, property) {\n\t if (property) {\n\t primary = primary[property];\n\t secondary = secondary[property];\n\t }\n\t if (secondary && primary) {\n\t _angularFix2['default'].forEach(secondary, function (item) {\n\t if (primary.indexOf(item) === -1) {\n\t primary.push(item);\n\t }\n\t });\n\t return primary;\n\t } else if (secondary) {\n\t return secondary;\n\t } else {\n\t return primary;\n\t }\n\t}\n\t\n\tfunction startsWith(str, search) {\n\t if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {\n\t return str.length >= search.length && str.substring(0, search.length) === search;\n\t } else {\n\t return false;\n\t }\n\t}\n\t\n\tfunction contains(str, search) {\n\t if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {\n\t return str.length >= search.length && str.indexOf(search) !== -1;\n\t } else {\n\t return false;\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports[\"default\"] = \"https://github.com/formly-js/angular-formly/blob/\" + (\"8.1.0\") + \"/other/ERRORS_AND_WARNINGS.md#\";\n\tmodule.exports = exports[\"default\"];\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_4__;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tformlyCustomValidation.$inject = [\"formlyUtil\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\texports['default'] = formlyCustomValidation;\n\t\n\t// @ngInject\n\tfunction formlyCustomValidation(formlyUtil) {\n\t return {\n\t restrict: 'A',\n\t require: 'ngModel',\n\t link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {\n\t var opts = scope.options;\n\t opts.validation.messages = opts.validation.messages || {};\n\t _angularFix2['default'].forEach(opts.validation.messages, function (message, key) {\n\t opts.validation.messages[key] = function () {\n\t return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);\n\t };\n\t });\n\t\n\t var useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers');\n\t _angularFix2['default'].forEach(opts.validators, _angularFix2['default'].bind(null, addValidatorToPipeline, false));\n\t _angularFix2['default'].forEach(opts.asyncValidators, _angularFix2['default'].bind(null, addValidatorToPipeline, true));\n\t\n\t function addValidatorToPipeline(isAsync, validator, name) {\n\t setupMessage(validator, name);\n\t validator = _angularFix2['default'].isObject(validator) ? validator.expression : validator;\n\t if (useNewValidatorsApi) {\n\t setupWithValidators(validator, name, isAsync);\n\t } else {\n\t setupWithParsers(validator, name, isAsync);\n\t }\n\t }\n\t\n\t function setupMessage(validator, name) {\n\t var message = validator.message;\n\t if (message) {\n\t opts.validation.messages[name] = function () {\n\t return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);\n\t };\n\t }\n\t }\n\t\n\t function setupWithValidators(validator, name, isAsync) {\n\t var validatorCollection = isAsync ? '$asyncValidators' : '$validators';\n\t\n\t ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {\n\t return formlyUtil.formlyEval(scope, validator, modelValue, viewValue);\n\t };\n\t }\n\t\n\t function setupWithParsers(validator, name, isAsync) {\n\t var inFlightValidator = undefined;\n\t ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {\n\t var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);\n\t if (isAsync) {\n\t ctrl.$pending = ctrl.$pending || {};\n\t ctrl.$pending[name] = true;\n\t inFlightValidator = isValid;\n\t isValid.then(function () {\n\t if (inFlightValidator === isValid) {\n\t ctrl.$setValidity(name, true);\n\t }\n\t })['catch'](function () {\n\t if (inFlightValidator === isValid) {\n\t ctrl.$setValidity(name, false);\n\t }\n\t })['finally'](function () {\n\t var $pending = ctrl.$pending || {};\n\t if (Object.keys($pending).length === 1) {\n\t delete ctrl.$pending;\n\t } else {\n\t delete ctrl.$pending[name];\n\t }\n\t });\n\t } else {\n\t ctrl.$setValidity(name, isValid);\n\t }\n\t return viewValue;\n\t });\n\t }\n\t }\n\t };\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tformlyField.$inject = [\"$http\", \"$q\", \"$compile\", \"$templateCache\", \"$interpolate\", \"formlyConfig\", \"formlyApiCheck\", \"formlyUtil\", \"formlyUsability\", \"formlyWarn\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\tvar _apiCheck = __webpack_require__(4);\n\t\n\tvar _apiCheck2 = _interopRequireDefault(_apiCheck);\n\t\n\texports['default'] = formlyField;\n\t\n\t/**\n\t * @ngdoc directive\n\t * @name formlyField\n\t * @restrict AE\n\t */\n\t// @ngInject\n\tfunction formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {\n\t FormlyFieldController.$inject = [\"$scope\", \"$timeout\", \"$parse\", \"$controller\", \"formlyValidationMessages\"];\n\t var arrayify = formlyUtil.arrayify;\n\t\n\t return {\n\t restrict: 'AE',\n\t transclude: true,\n\t require: '?^formlyForm',\n\t scope: {\n\t options: '=',\n\t model: '=',\n\t originalModel: '=?',\n\t formId: '@', // TODO remove formId in a breaking release\n\t index: '=?',\n\t fields: '=?',\n\t formState: '=?',\n\t formOptions: '=?',\n\t form: '=?' },\n\t // TODO require form in a breaking release\n\t controller: FormlyFieldController,\n\t link: fieldLink\n\t };\n\t\n\t // @ngInject\n\t function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) {\n\t /* eslint max-statements:[2, 34] */\n\t if ($scope.options.fieldGroup) {\n\t setupFieldGroup();\n\t return;\n\t }\n\t\n\t var fieldType = getFieldType($scope.options);\n\t simplifyLife($scope.options);\n\t mergeFieldOptionsWithTypeDefaults($scope.options, fieldType);\n\t extendOptionsWithDefaults($scope.options, $scope.index);\n\t checkApi($scope.options);\n\t // set field id to link labels and fields\n\t\n\t // initalization\n\t setFieldIdAndName();\n\t setDefaultValue();\n\t setInitialValue();\n\t runExpressions();\n\t watchExpressions();\n\t addValidationMessages($scope.options);\n\t invokeControllers($scope, $scope.options, fieldType);\n\t\n\t // function definitions\n\t function runExpressions() {\n\t // must run on next tick to make sure that the current value is correct.\n\t return $timeout(function runExpressionsOnNextTick() {\n\t var field = $scope.options;\n\t var currentValue = valueGetterSetter();\n\t _angularFix2['default'].forEach(field.expressionProperties, function runExpression(expression, prop) {\n\t var setter = $parse(prop).assign;\n\t var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue));\n\t promise.then(function setFieldValue(value) {\n\t setter(field, value);\n\t });\n\t });\n\t }, 0, false);\n\t }\n\t\n\t function watchExpressions() {\n\t if ($scope.formOptions.watchAllExpressions) {\n\t (function () {\n\t var field = $scope.options;\n\t var currentValue = valueGetterSetter();\n\t _angularFix2['default'].forEach(field.expressionProperties, function watchExpression(expression, prop) {\n\t var setter = $parse(prop).assign;\n\t $scope.$watch(function expressionPropertyWatcher() {\n\t return formlyUtil.formlyEval($scope, expression, currentValue, currentValue);\n\t }, function expressionPropertyListener(value) {\n\t setter(field, value);\n\t }, true);\n\t });\n\t })();\n\t }\n\t }\n\t\n\t function valueGetterSetter(newVal) {\n\t if (!$scope.model || !$scope.options.key) {\n\t return undefined;\n\t }\n\t if (_angularFix2['default'].isDefined(newVal)) {\n\t parseSet($scope.options.key, $scope.model, newVal);\n\t }\n\t return parseGet($scope.options.key, $scope.model);\n\t }\n\t\n\t function shouldNotUseParseKey(key) {\n\t return _angularFix2['default'].isNumber(key) || !formlyUtil.containsSelector(key);\n\t }\n\t\n\t function parseSet(key, model, newVal) {\n\t // If either of these are null/undefined then just return undefined\n\t if (!key && key !== 0 || !model) {\n\t return;\n\t }\n\t // If we are working with a number then $parse wont work, default back to the old way for now\n\t if (shouldNotUseParseKey(key)) {\n\t // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n\t model[key] = newVal;\n\t } else {\n\t var setter = $parse($scope.options.key).assign;\n\t if (setter) {\n\t setter($scope.model, newVal);\n\t }\n\t }\n\t }\n\t\n\t function parseGet(key, model) {\n\t // If either of these are null/undefined then just return undefined\n\t if (!key && key !== 0 || !model) {\n\t return undefined;\n\t }\n\t\n\t // If we are working with a number then $parse wont work, default back to the old way for now\n\t if (shouldNotUseParseKey(key)) {\n\t // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n\t return model[key];\n\t } else {\n\t return $parse(key)(model);\n\t }\n\t }\n\t\n\t function simplifyLife(options) {\n\t // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere\n\t formlyUtil.reverseDeepMerge(options, {\n\t originalModel: options.model,\n\t extras: {},\n\t data: {},\n\t templateOptions: {},\n\t validation: {}\n\t });\n\t // create $scope.to so template authors can reference to instead of $scope.options.templateOptions\n\t $scope.to = $scope.options.templateOptions;\n\t $scope.formOptions = $scope.formOptions || {};\n\t }\n\t\n\t function setFieldIdAndName() {\n\t if (_angularFix2['default'].isFunction(formlyConfig.extras.getFieldId)) {\n\t $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope);\n\t } else {\n\t var formName = $scope.form && $scope.form.$name || $scope.formId;\n\t $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index);\n\t }\n\t $scope.options.id = $scope.id;\n\t $scope.name = $scope.options.name || $scope.options.id;\n\t $scope.options.name = $scope.name;\n\t }\n\t\n\t function setDefaultValue() {\n\t if (_angularFix2['default'].isDefined($scope.options.defaultValue) && !_angularFix2['default'].isDefined(parseGet($scope.options.key, $scope.model))) {\n\t parseSet($scope.options.key, $scope.model, $scope.options.defaultValue);\n\t }\n\t }\n\t\n\t function setInitialValue() {\n\t $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model);\n\t }\n\t\n\t function mergeFieldOptionsWithTypeDefaults(options, type) {\n\t if (type) {\n\t mergeOptions(options, type.defaultOptions);\n\t }\n\t var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden\n\t _angularFix2['default'].forEach(properOrder, function (typeName) {\n\t mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions);\n\t });\n\t }\n\t\n\t function mergeOptions(options, extraOptions) {\n\t if (extraOptions) {\n\t if (_angularFix2['default'].isFunction(extraOptions)) {\n\t extraOptions = extraOptions(options, $scope);\n\t }\n\t formlyUtil.reverseDeepMerge(options, extraOptions);\n\t }\n\t }\n\t\n\t function extendOptionsWithDefaults(options, index) {\n\t var key = options.key || index || 0;\n\t _angularFix2['default'].extend(options, {\n\t // attach the key in case the formly-field directive is used directly\n\t key: key,\n\t value: options.value || valueGetterSetter,\n\t runExpressions: runExpressions,\n\t resetModel: resetModel,\n\t updateInitialValue: updateInitialValue\n\t });\n\t }\n\t\n\t function resetModel() {\n\t parseSet($scope.options.key, $scope.model, $scope.options.initialValue);\n\t if ($scope.options.formControl) {\n\t if (_angularFix2['default'].isArray($scope.options.formControl)) {\n\t _angularFix2['default'].forEach($scope.options.formControl, function (formControl) {\n\t resetFormControl(formControl, true);\n\t });\n\t } else {\n\t resetFormControl($scope.options.formControl);\n\t }\n\t }\n\t if ($scope.form) {\n\t $scope.form.$setUntouched && $scope.form.$setUntouched();\n\t $scope.form.$setPristine();\n\t }\n\t }\n\t\n\t function resetFormControl(formControl, isMultiNgModel) {\n\t if (!isMultiNgModel) {\n\t formControl.$setViewValue(parseGet($scope.options.key, $scope.model));\n\t }\n\t\n\t formControl.$render();\n\t formControl.$setUntouched && formControl.$setUntouched();\n\t formControl.$setPristine();\n\t\n\t // To prevent breaking change requiring a digest to reset $viewModel\n\t if (!$scope.$root.$$phase) {\n\t $scope.$digest();\n\t }\n\t }\n\t\n\t function updateInitialValue() {\n\t $scope.options.initialValue = parseGet($scope.options.key, $scope.model);\n\t }\n\t\n\t function addValidationMessages(options) {\n\t options.validation.messages = options.validation.messages || {};\n\t _angularFix2['default'].forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) {\n\t if (!options.validation.messages[name]) {\n\t options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) {\n\t return formlyUtil.formlyEval(scope, expression, modelValue, viewValue);\n\t };\n\t }\n\t });\n\t }\n\t\n\t function invokeControllers(scope) {\n\t var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\t var type = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n\t\n\t _angularFix2['default'].forEach([type.controller, options.controller], function (controller) {\n\t if (controller) {\n\t $controller(controller, { $scope: scope });\n\t }\n\t });\n\t }\n\t\n\t function setupFieldGroup() {\n\t $scope.options.options = $scope.options.options || {};\n\t $scope.options.options.formState = $scope.formState;\n\t $scope.to = $scope.options.templateOptions;\n\t }\n\t }\n\t\n\t // link function\n\t function fieldLink(scope, el, attrs, formlyFormCtrl) {\n\t if (scope.options.fieldGroup) {\n\t setFieldGroupTemplate();\n\t return;\n\t }\n\t\n\t // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead)\n\t if (!formlyFormCtrl && scope.options.model) {\n\t scope.$watch('options.model', function () {\n\t return scope.options.runExpressions();\n\t }, true);\n\t }\n\t\n\t addAttributes();\n\t addClasses();\n\t\n\t var type = getFieldType(scope.options);\n\t var args = arguments;\n\t var thusly = this;\n\t var fieldCount = 0;\n\t var fieldManipulators = getManipulators(scope.options, scope.formOptions);\n\t getFieldTemplate(scope.options).then(runManipulators(fieldManipulators.preWrapper)).then(transcludeInWrappers(scope.options, scope.formOptions)).then(runManipulators(fieldManipulators.postWrapper)).then(setElementTemplate).then(watchFormControl).then(callLinkFunctions)['catch'](function (error) {\n\t formlyWarn('there-was-a-problem-setting-the-template-for-this-field', 'There was a problem setting the template for this field ', scope.options, error);\n\t });\n\t\n\t function setFieldGroupTemplate() {\n\t checkFieldGroupApi(scope.options);\n\t el.addClass('formly-field-group');\n\t var extraAttributes = '';\n\t if (scope.options.elementAttributes) {\n\t extraAttributes = Object.keys(scope.options.elementAttributes).map(function (key) {\n\t return key + '=\"' + scope.options.elementAttributes[key] + '\"';\n\t }).join(' ');\n\t }\n\t var modelValue = 'model';\n\t scope.options.form = scope.form;\n\t if (scope.options.key) {\n\t modelValue = 'model[\\'' + scope.options.key + '\\']';\n\t }\n\t getTemplate('\\n \\n \\n ').then(transcludeInWrappers(scope.options, scope.formOptions)).then(setElementTemplate);\n\t }\n\t\n\t function addAttributes() {\n\t if (scope.options.elementAttributes) {\n\t el.attr(scope.options.elementAttributes);\n\t }\n\t }\n\t\n\t function addClasses() {\n\t if (scope.options.className) {\n\t el.addClass(scope.options.className);\n\t }\n\t if (scope.options.type) {\n\t el.addClass('formly-field-' + scope.options.type);\n\t }\n\t }\n\t\n\t function setElementTemplate(templateString) {\n\t el.html(asHtml(templateString));\n\t $compile(el.contents())(scope);\n\t return templateString;\n\t }\n\t\n\t function watchFormControl(templateString) {\n\t var stopWatchingShowError = _angularFix2['default'].noop;\n\t if (scope.options.noFormControl) {\n\t return;\n\t }\n\t var templateEl = _angularFix2['default'].element('
' + templateString + '
');\n\t var ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]');\n\t\n\t if (ngModelNodes.length) {\n\t _angularFix2['default'].forEach(ngModelNodes, function (ngModelNode) {\n\t fieldCount++;\n\t watchFieldNameOrExistence(ngModelNode.getAttribute('name'));\n\t });\n\t }\n\t\n\t function watchFieldNameOrExistence(name) {\n\t var nameExpressionRegex = /\\{\\{(.*?)}}/;\n\t var nameExpression = nameExpressionRegex.exec(name);\n\t if (nameExpression) {\n\t name = $interpolate(name)(scope);\n\t }\n\t watchFieldExistence(name);\n\t }\n\t\n\t function watchFieldExistence(name) {\n\t scope.$watch('form[\"' + name + '\"]', function formControlChange(formControl) {\n\t if (formControl) {\n\t if (fieldCount > 1) {\n\t if (!scope.options.formControl) {\n\t scope.options.formControl = [];\n\t }\n\t scope.options.formControl.push(formControl);\n\t } else {\n\t scope.options.formControl = formControl;\n\t }\n\t scope.fc = scope.options.formControl; // shortcut for template authors\n\t stopWatchingShowError();\n\t addShowMessagesWatcher();\n\t addParsers();\n\t addFormatters();\n\t }\n\t });\n\t }\n\t\n\t function addShowMessagesWatcher() {\n\t stopWatchingShowError = scope.$watch(function watchShowValidationChange() {\n\t var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression;\n\t var options = scope.options;\n\t var formControls = arrayify(scope.fc);\n\t if (!formControls.some(function (fc) {\n\t return fc.$invalid;\n\t })) {\n\t return false;\n\t } else if (typeof options.validation.show === 'boolean') {\n\t return options.validation.show;\n\t } else if (customExpression) {\n\t return formControls.some(function (fc) {\n\t return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue);\n\t });\n\t } else {\n\t return formControls.some(function (fc) {\n\t var noTouchedButDirty = _angularFix2['default'].isUndefined(fc.$touched) && fc.$dirty;\n\t return fc.$touched || noTouchedButDirty;\n\t });\n\t }\n\t }, function onShowValidationChange(show) {\n\t scope.options.validation.errorExistsAndShouldBeVisible = show;\n\t scope.showError = show; // shortcut for template authors\n\t });\n\t }\n\t\n\t function addParsers() {\n\t setParsersOrFormatters('parsers');\n\t }\n\t\n\t function addFormatters() {\n\t setParsersOrFormatters('formatters');\n\t var ctrl = scope.fc;\n\t var formWasPristine = scope.form.$pristine;\n\t if (scope.options.formatters) {\n\t (function () {\n\t var value = ctrl.$modelValue;\n\t ctrl.$formatters.forEach(function (formatter) {\n\t value = formatter(value);\n\t });\n\t\n\t ctrl.$setViewValue(value);\n\t ctrl.$render();\n\t ctrl.$setPristine();\n\t if (formWasPristine) {\n\t scope.form.$setPristine();\n\t }\n\t })();\n\t }\n\t }\n\t\n\t function setParsersOrFormatters(which) {\n\t var originalThingProp = 'originalParser';\n\t if (which === 'formatters') {\n\t originalThingProp = 'originalFormatter';\n\t }\n\t\n\t // init with type's parsers\n\t var things = getThingsFromType(type);\n\t\n\t // get optionsTypes things\n\t things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes));\n\t\n\t // get field's things\n\t things = formlyUtil.extendArray(things, scope.options[which]);\n\t\n\t // convert things into formlyExpression things\n\t _angularFix2['default'].forEach(things, function (thing, index) {\n\t things[index] = getFormlyExpressionThing(thing);\n\t });\n\t\n\t var ngModelCtrls = scope.fc;\n\t if (!_angularFix2['default'].isArray(ngModelCtrls)) {\n\t ngModelCtrls = [ngModelCtrls];\n\t }\n\t\n\t _angularFix2['default'].forEach(ngModelCtrls, function (ngModelCtrl) {\n\t var _ngModelCtrl;\n\t\n\t ngModelCtrl['$' + which] = (_ngModelCtrl = ngModelCtrl['$' + which]).concat.apply(_ngModelCtrl, _toConsumableArray(things));\n\t });\n\t\n\t function getThingsFromType(theType) {\n\t if (!theType) {\n\t return [];\n\t }\n\t if (_angularFix2['default'].isString(theType)) {\n\t theType = formlyConfig.getType(theType, true, scope.options);\n\t }\n\t var typeThings = [];\n\t\n\t // get things from parent\n\t if (theType['extends']) {\n\t typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType['extends']));\n\t }\n\t\n\t // get own type's things\n\t typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, []));\n\t\n\t // get things from optionsTypes\n\t typeThings = formlyUtil.extendArray(typeThings, getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType)));\n\t\n\t return typeThings;\n\t }\n\t\n\t function getThingsFromOptionsTypes() {\n\t var optionsTypes = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];\n\t\n\t var optionsTypesThings = [];\n\t _angularFix2['default'].forEach(_angularFix2['default'].copy(arrayify(optionsTypes)).reverse(), function (optionsTypeName) {\n\t optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName));\n\t });\n\t return optionsTypesThings;\n\t }\n\t\n\t function getFormlyExpressionThing(thing) {\n\t formlyExpressionParserOrFormatterFunction[originalThingProp] = thing;\n\t return formlyExpressionParserOrFormatterFunction;\n\t\n\t function formlyExpressionParserOrFormatterFunction($viewValue) {\n\t var $modelValue = scope.options.value();\n\t return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue);\n\t }\n\t }\n\t }\n\t }\n\t\n\t function callLinkFunctions() {\n\t if (type && type.link) {\n\t type.link.apply(thusly, args);\n\t }\n\t if (scope.options.link) {\n\t scope.options.link.apply(thusly, args);\n\t }\n\t }\n\t\n\t function runManipulators(manipulators) {\n\t return function runManipulatorsOnTemplate(templateToManipulate) {\n\t var chain = $q.when(templateToManipulate);\n\t _angularFix2['default'].forEach(manipulators, function (manipulator) {\n\t chain = chain.then(function (template) {\n\t return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) {\n\t return _angularFix2['default'].isString(newTemplate) ? newTemplate : asHtml(newTemplate);\n\t });\n\t });\n\t });\n\t return chain;\n\t };\n\t }\n\t }\n\t\n\t // sort-of stateless util functions\n\t function asHtml(el) {\n\t var wrapper = _angularFix2['default'].element('');\n\t return wrapper.append(el).html();\n\t }\n\t\n\t function getFieldType(options) {\n\t return options.type && formlyConfig.getType(options.type);\n\t }\n\t\n\t function getManipulators(options, formOptions) {\n\t var preWrapper = [];\n\t var postWrapper = [];\n\t addManipulators(options.templateManipulators);\n\t addManipulators(formOptions.templateManipulators);\n\t addManipulators(formlyConfig.templateManipulators);\n\t return { preWrapper: preWrapper, postWrapper: postWrapper };\n\t\n\t function addManipulators(manipulators) {\n\t /* eslint-disable */ // it doesn't understand this :-(\n\t\n\t var _ref = manipulators || {};\n\t\n\t var _ref$preWrapper = _ref.preWrapper;\n\t var pre = _ref$preWrapper === undefined ? [] : _ref$preWrapper;\n\t var _ref$postWrapper = _ref.postWrapper;\n\t var post = _ref$postWrapper === undefined ? [] : _ref$postWrapper;\n\t\n\t preWrapper = preWrapper.concat(pre);\n\t postWrapper = postWrapper.concat(post);\n\t /* eslint-enable */\n\t }\n\t }\n\t\n\t function getFieldTemplate(options) {\n\t function fromOptionsOrType(key, fieldType) {\n\t if (_angularFix2['default'].isDefined(options[key])) {\n\t return options[key];\n\t } else if (fieldType && _angularFix2['default'].isDefined(fieldType[key])) {\n\t return fieldType[key];\n\t }\n\t }\n\t\n\t var type = formlyConfig.getType(options.type, true, options);\n\t var template = fromOptionsOrType('template', type);\n\t var templateUrl = fromOptionsOrType('templateUrl', type);\n\t if (_angularFix2['default'].isUndefined(template) && !templateUrl) {\n\t throw formlyUsability.getFieldError('type-type-has-no-template', 'Type \\'' + options.type + '\\' has no template. On element:', options);\n\t }\n\t\n\t return getTemplate(templateUrl || template, _angularFix2['default'].isUndefined(template), options);\n\t }\n\t\n\t function getTemplate(template, isUrl, options) {\n\t var templatePromise = undefined;\n\t if (_angularFix2['default'].isFunction(template)) {\n\t templatePromise = $q.when(template(options));\n\t } else {\n\t templatePromise = $q.when(template);\n\t }\n\t\n\t if (!isUrl) {\n\t return templatePromise;\n\t } else {\n\t var _ret3 = (function () {\n\t var httpOptions = { cache: $templateCache };\n\t return {\n\t v: templatePromise.then(function (url) {\n\t return $http.get(url, httpOptions);\n\t }).then(function (response) {\n\t return response.data;\n\t })['catch'](function handleErrorGettingATemplate(error) {\n\t formlyWarn('problem-loading-template-for-templateurl', 'Problem loading template for ' + template, error);\n\t })\n\t };\n\t })();\n\t\n\t if (typeof _ret3 === 'object') return _ret3.v;\n\t }\n\t }\n\t\n\t function transcludeInWrappers(options, formOptions) {\n\t var wrapper = getWrapperOption(options, formOptions);\n\t\n\t return function transcludeTemplate(template) {\n\t if (!wrapper.length) {\n\t return $q.when(template);\n\t }\n\t\n\t wrapper.forEach(function (aWrapper) {\n\t formlyUsability.checkWrapper(aWrapper, options);\n\t runApiCheck(aWrapper, options);\n\t });\n\t var promises = wrapper.map(function (w) {\n\t return getTemplate(w.template || w.templateUrl, !w.template);\n\t });\n\t return $q.all(promises).then(function (wrappersTemplates) {\n\t wrappersTemplates.forEach(function (wrapperTemplate, index) {\n\t formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index]);\n\t });\n\t wrappersTemplates.reverse(); // wrapper 0 is wrapped in wrapper 1 and so on...\n\t var totalWrapper = wrappersTemplates.shift();\n\t wrappersTemplates.forEach(function (wrapperTemplate) {\n\t totalWrapper = doTransclusion(totalWrapper, wrapperTemplate);\n\t });\n\t return doTransclusion(totalWrapper, template);\n\t });\n\t };\n\t }\n\t\n\t function doTransclusion(wrapper, template) {\n\t var superWrapper = _angularFix2['default'].element(''); // this allows people not have to have a single root in wrappers\n\t superWrapper.append(wrapper);\n\t var transcludeEl = superWrapper.find('formly-transclude');\n\t if (!transcludeEl.length) {\n\t // try it using our custom find function\n\t transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude');\n\t }\n\t transcludeEl.replaceWith(template);\n\t return superWrapper.html();\n\t }\n\t\n\t function getWrapperOption(options, formOptions) {\n\t /* eslint complexity:[2, 6] */\n\t var wrapper = options.wrapper;\n\t // explicit null means no wrapper\n\t if (wrapper === null) {\n\t return [];\n\t }\n\t\n\t // nothing specified means use the default wrapper for the type\n\t if (!wrapper) {\n\t // get all wrappers that specify they apply to this type\n\t wrapper = arrayify(formlyConfig.getWrapperByType(options.type));\n\t } else {\n\t wrapper = arrayify(wrapper).map(formlyConfig.getWrapper);\n\t }\n\t\n\t // get all wrappers for that the type specified that it uses.\n\t var type = formlyConfig.getType(options.type, true, options);\n\t if (type && type.wrapper) {\n\t var typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper);\n\t wrapper = wrapper.concat(typeWrappers);\n\t }\n\t\n\t // add form wrappers\n\t if (formOptions.wrapper) {\n\t var formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper);\n\t wrapper = wrapper.concat(formWrappers);\n\t }\n\t\n\t // add the default wrapper last\n\t var defaultWrapper = formlyConfig.getWrapper();\n\t if (defaultWrapper) {\n\t wrapper.push(defaultWrapper);\n\t }\n\t return wrapper;\n\t }\n\t\n\t function checkApi(options) {\n\t formlyApiCheck['throw'](formlyApiCheck.formlyFieldOptions, options, {\n\t prefix: 'formly-field directive',\n\t url: 'formly-field-directive-validation-failed'\n\t });\n\t // validate with the type\n\t var type = options.type && formlyConfig.getType(options.type);\n\t if (type) {\n\t runApiCheck(type, options, true);\n\t }\n\t if (options.expressionProperties && options.expressionProperties.hide) {\n\t formlyWarn('dont-use-expressionproperties.hide-use-hideexpression-instead', 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead', options);\n\t }\n\t }\n\t\n\t function checkFieldGroupApi(options) {\n\t formlyApiCheck['throw'](formlyApiCheck.fieldGroup, options, {\n\t prefix: 'formly-field directive',\n\t url: 'formly-field-directive-validation-failed'\n\t });\n\t }\n\t\n\t function runApiCheck(_ref2, options, forType) {\n\t var apiCheck = _ref2.apiCheck;\n\t var apiCheckInstance = _ref2.apiCheckInstance;\n\t var apiCheckFunction = _ref2.apiCheckFunction;\n\t var apiCheckOptions = _ref2.apiCheckOptions;\n\t\n\t runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options);\n\t if (forType && options.type) {\n\t _angularFix2['default'].forEach(formlyConfig.getTypeHeritage(options.type), function (type) {\n\t runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options);\n\t });\n\t }\n\t }\n\t\n\t function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) {\n\t /* eslint complexity:[2, 9] */\n\t if (!apiCheck) {\n\t return;\n\t }\n\t var instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck;\n\t if (instance.config.disabled || _apiCheck2['default'].globalConfig.disabled) {\n\t return;\n\t }\n\t var fn = apiCheckFunction || 'warn';\n\t // this is the new API\n\t var checkerObjects = apiCheck(instance);\n\t _angularFix2['default'].forEach(checkerObjects, function (shape, name) {\n\t var checker = instance.shape(shape);\n\t var checkOptions = _angularFix2['default'].extend({\n\t prefix: 'formly-field type ' + options.type + ' for property ' + name,\n\t url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed'\n\t }, apiCheckOptions);\n\t instance[fn](checker, options[name], checkOptions);\n\t });\n\t }\n\t}\n\t\n\t// Stateless util functions\n\tfunction getDefaultOptionsOptionsTypes(type) {\n\t return getDefaultOptionsProperty(type, 'optionsTypes', []);\n\t}\n\t\n\tfunction getDefaultOptionsProperty(type, prop, defaultValue) {\n\t return type.defaultOptions && type.defaultOptions[prop] || defaultValue;\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 7 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tformlyFocus.$inject = [\"$timeout\", \"$document\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\texports['default'] = formlyFocus;\n\t\n\t// @ngInject\n\tfunction formlyFocus($timeout, $document) {\n\t return {\n\t restrict: 'A',\n\t link: function formlyFocusLink(scope, element, attrs) {\n\t var previousEl = null;\n\t var el = element[0];\n\t var doc = $document[0];\n\t attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) {\n\t /* eslint no-bitwise:0 */ // I know what I'm doing. I promise...\n\t if (value === 'true') {\n\t $timeout(function setElementFocus() {\n\t previousEl = doc.activeElement;\n\t el.focus();\n\t }, ~ ~attrs.focusWait);\n\t } else if (value === 'false') {\n\t if (doc.activeElement === el) {\n\t el.blur();\n\t if (attrs.hasOwnProperty('refocus') && previousEl) {\n\t previousEl.focus();\n\t }\n\t }\n\t }\n\t });\n\t }\n\t };\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 8 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tformlyForm.$inject = [\"formlyUsability\", \"formlyWarn\", \"$parse\", \"formlyConfig\", \"$interpolate\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\tvar _slice = Array.prototype.slice;\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\texports['default'] = formlyForm;\n\t\n\t/**\n\t * @ngdoc directive\n\t * @name formlyForm\n\t * @restrict AE\n\t */\n\t// @ngInject\n\tfunction formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) {\n\t FormlyFormController.$inject = [\"$scope\", \"formlyApiCheck\", \"formlyUtil\"];\n\t var currentFormId = 1;\n\t return {\n\t restrict: 'AE',\n\t template: formlyFormGetTemplate,\n\t replace: true,\n\t transclude: true,\n\t scope: {\n\t fields: '=',\n\t model: '=',\n\t form: '=?',\n\t options: '=?'\n\t },\n\t controller: FormlyFormController,\n\t link: formlyFormLink\n\t };\n\t\n\t function formlyFormGetTemplate(el, attrs) {\n\t var rootEl = getRootEl();\n\t var fieldRootEl = getFieldRootEl();\n\t var formId = 'formly_' + currentFormId++;\n\t var parentFormAttributes = '';\n\t if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) {\n\t parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes);\n\t }\n\t return '\\n <' + rootEl + ' class=\"formly\"\\n name=\"' + getFormName() + '\"\\n role=\"form\" ' + parentFormAttributes + '>\\n <' + fieldRootEl + ' formly-field\\n ng-repeat=\"field in fields ' + getTrackBy() + '\"\\n ' + getHideDirective() + '=\"!field.hide\"\\n class=\"formly-field\"\\n options=\"field\"\\n model=\"field.model || model\"\\n original-model=\"model\"\\n fields=\"fields\"\\n form=\"theFormlyForm\"\\n form-id=\"' + getFormName() + '\"\\n form-state=\"options.formState\"\\n form-options=\"options\"\\n index=\"$index\">\\n \\n
\\n \\n ';\n\t\n\t function getRootEl() {\n\t return attrs.rootEl || 'ng-form';\n\t }\n\t\n\t function getFieldRootEl() {\n\t return attrs.fieldRootEl || 'div';\n\t }\n\t\n\t function getHideDirective() {\n\t return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if';\n\t }\n\t\n\t function getTrackBy() {\n\t if (!attrs.trackBy) {\n\t return '';\n\t } else {\n\t return 'track by ' + attrs.trackBy;\n\t }\n\t }\n\t\n\t function getFormName() {\n\t var formName = formId;\n\t var bindName = attrs.bindName;\n\t if (bindName) {\n\t if (_angularFix2['default'].version.minor < 3) {\n\t throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3');\n\t }\n\t // we can do a one-time binding here because we know we're in 1.3.x territory\n\t formName = $interpolate.startSymbol() + '::\\'formly_\\' + ' + bindName + $interpolate.endSymbol();\n\t }\n\t return formName;\n\t }\n\t\n\t function getTranscludeClass() {\n\t return attrs.transcludeClass || '';\n\t }\n\t\n\t function copyAttributes(attributes) {\n\t var excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class', 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name'];\n\t var arrayAttrs = [];\n\t _angularFix2['default'].forEach(attributes, function (_ref) {\n\t var nodeName = _ref.nodeName;\n\t var value = _ref.value;\n\t\n\t if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) {\n\t arrayAttrs.push(toKebabCase(nodeName) + '=\"' + value + '\"');\n\t }\n\t });\n\t return arrayAttrs.join(' ');\n\t }\n\t }\n\t\n\t // @ngInject\n\t function FormlyFormController($scope, formlyApiCheck, formlyUtil) {\n\t setupOptions();\n\t $scope.model = $scope.model || {};\n\t setupFields();\n\t\n\t // watch the model and evaluate watch expressions that depend on it.\n\t if (!$scope.options.manualModelWatcher) {\n\t $scope.$watch('model', onModelOrFormStateChange, true);\n\t } else if (_angularFix2['default'].isFunction($scope.options.manualModelWatcher)) {\n\t $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true);\n\t }\n\t\n\t if ($scope.options.formState) {\n\t $scope.$watch('options.formState', onModelOrFormStateChange, true);\n\t }\n\t\n\t function onModelOrFormStateChange() {\n\t _angularFix2['default'].forEach($scope.fields, runFieldExpressionProperties);\n\t }\n\t\n\t function validateFormControl(formControl, promise) {\n\t var validate = formControl.$validate;\n\t if (promise) {\n\t promise.then(validate);\n\t } else {\n\t validate();\n\t }\n\t }\n\t\n\t function runFieldExpressionProperties(field, index) {\n\t var model = field.model || $scope.model;\n\t var promise = field.runExpressions && field.runExpressions();\n\t if (field.hideExpression) {\n\t // can't use hide with expressionProperties reliably\n\t var val = model[field.key];\n\t field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });\n\t }\n\t if (field.extras && field.extras.validateOnModelChange && field.formControl) {\n\t if (_angularFix2['default'].isArray(field.formControl)) {\n\t _angularFix2['default'].forEach(field.formControl, function (formControl) {\n\t validateFormControl(formControl, promise);\n\t });\n\t } else {\n\t validateFormControl(field.formControl, promise);\n\t }\n\t }\n\t }\n\t\n\t function setupFields() {\n\t $scope.fields = $scope.fields || [];\n\t\n\t checkDeprecatedOptions($scope.options);\n\t\n\t var fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform;\n\t\n\t if (!_angularFix2['default'].isArray(fieldTransforms)) {\n\t fieldTransforms = [fieldTransforms];\n\t }\n\t\n\t _angularFix2['default'].forEach(fieldTransforms, function transformFields(fieldTransform) {\n\t if (fieldTransform) {\n\t $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form);\n\t if (!$scope.fields) {\n\t throw formlyUsability.getFormlyError('fieldTransform must return an array of fields');\n\t }\n\t }\n\t });\n\t\n\t setupModels();\n\t\n\t if ($scope.options.watchAllExpressions) {\n\t _angularFix2['default'].forEach($scope.fields, setupHideExpressionWatcher);\n\t }\n\t\n\t _angularFix2['default'].forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified\n\t _angularFix2['default'].forEach($scope.fields, setupWatchers); // setup watchers for all fields\n\t }\n\t\n\t function checkDeprecatedOptions(options) {\n\t if (formlyConfig.extras.fieldTransform && _angularFix2['default'].isFunction(formlyConfig.extras.fieldTransform)) {\n\t formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for formlyConfig.extras: ' + formlyConfig.extras.fieldTransform.name, formlyConfig.extras);\n\t } else if (options.fieldTransform && _angularFix2['default'].isFunction(options.fieldTransform)) {\n\t formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for form', options);\n\t }\n\t }\n\t\n\t function setupOptions() {\n\t formlyApiCheck['throw']([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: 'formly-form options check' });\n\t $scope.options = $scope.options || {};\n\t $scope.options.formState = $scope.options.formState || {};\n\t\n\t _angularFix2['default'].extend($scope.options, {\n\t updateInitialValue: updateInitialValue,\n\t resetModel: resetModel\n\t });\n\t }\n\t\n\t function updateInitialValue() {\n\t _angularFix2['default'].forEach($scope.fields, function (field) {\n\t if (isFieldGroup(field) && field.options) {\n\t field.options.updateInitialValue();\n\t } else {\n\t field.updateInitialValue();\n\t }\n\t });\n\t }\n\t\n\t function resetModel() {\n\t _angularFix2['default'].forEach($scope.fields, function (field) {\n\t if (isFieldGroup(field) && field.options) {\n\t field.options.resetModel();\n\t } else if (field.resetModel) {\n\t field.resetModel();\n\t }\n\t });\n\t }\n\t\n\t function setupModels() {\n\t // a set of field models that are already watched (the $scope.model will have its own watcher)\n\t var watchedModels = [$scope.model];\n\t // we will not set up automatic model watchers if manual mode is set\n\t var manualModelWatcher = $scope.options.manualModelWatcher;\n\t\n\t if ($scope.options.formState) {\n\t // $scope.options.formState will have its own watcher\n\t watchedModels.push($scope.options.formState);\n\t }\n\t\n\t _angularFix2['default'].forEach($scope.fields, function (field) {\n\t var isNewModel = initModel(field);\n\t\n\t if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) {\n\t $scope.$watch(function () {\n\t return field.model;\n\t }, onModelOrFormStateChange, true);\n\t watchedModels.push(field.model);\n\t }\n\t });\n\t }\n\t\n\t function setupHideExpressionWatcher(field, index) {\n\t if (field.hideExpression) {\n\t (function () {\n\t // can't use hide with expressionProperties reliably\n\t var model = field.model || $scope.model;\n\t $scope.$watch(function hideExpressionWatcher() {\n\t var val = model[field.key];\n\t return evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });\n\t }, function (hide) {\n\t return field.hide = hide;\n\t }, true);\n\t })();\n\t }\n\t }\n\t\n\t function initModel(field) {\n\t var isNewModel = true;\n\t\n\t if (_angularFix2['default'].isString(field.model)) {\n\t (function () {\n\t var expression = field.model;\n\t\n\t isNewModel = !referencesCurrentlyWatchedModel(expression);\n\t\n\t field.model = resolveStringModel(expression);\n\t\n\t $scope.$watch(function () {\n\t return resolveStringModel(expression);\n\t }, function (model) {\n\t return field.model = model;\n\t });\n\t })();\n\t }\n\t\n\t return isNewModel;\n\t\n\t function resolveStringModel(expression) {\n\t var index = $scope.fields.indexOf(field);\n\t var model = evalCloseToFormlyExpression(expression, undefined, field, index, { model: $scope.model });\n\t\n\t if (!model) {\n\t throw formlyUsability.getFieldError('field-model-must-be-initialized', 'Field model must be initialized. When specifying a model as a string for a field, the result of the' + ' expression must have been initialized ahead of time.', field);\n\t }\n\t\n\t return model;\n\t }\n\t }\n\t\n\t function referencesCurrentlyWatchedModel(expression) {\n\t return ['model', 'formState'].some(function (item) {\n\t return formlyUtil.startsWith(expression, item + '.') || formlyUtil.startsWith(expression, item + '[');\n\t });\n\t }\n\t\n\t function attachKey(field, index) {\n\t if (!isFieldGroup(field)) {\n\t field.key = field.key || index || 0;\n\t }\n\t }\n\t\n\t function setupWatchers(field, index) {\n\t if (!_angularFix2['default'].isDefined(field.watcher)) {\n\t return;\n\t }\n\t var watchers = field.watcher;\n\t if (!_angularFix2['default'].isArray(watchers)) {\n\t watchers = [watchers];\n\t }\n\t _angularFix2['default'].forEach(watchers, function setupWatcher(watcher) {\n\t if (!_angularFix2['default'].isDefined(watcher.listener) && !watcher.runFieldExpressions) {\n\t throw formlyUsability.getFieldError('all-field-watchers-must-have-a-listener', 'All field watchers must have a listener', field);\n\t }\n\t var watchExpression = getWatchExpression(watcher, field, index);\n\t var watchListener = getWatchListener(watcher, field, index);\n\t\n\t var type = watcher.type || '$watch';\n\t watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep);\n\t });\n\t }\n\t\n\t function getWatchExpression(watcher, field, index) {\n\t var watchExpression = undefined;\n\t if (!_angularFix2['default'].isUndefined(watcher.expression)) {\n\t watchExpression = watcher.expression;\n\t } else if (field.key) {\n\t watchExpression = 'model[\\'' + field.key.toString().split('.').join('\\'][\\'') + '\\']';\n\t }\n\t if (_angularFix2['default'].isFunction(watchExpression)) {\n\t (function () {\n\t // wrap the field's watch expression so we can call it with the field as the first arg\n\t // and the stop function as the last arg as a helper\n\t var originalExpression = watchExpression;\n\t watchExpression = function formlyWatchExpression() {\n\t var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));\n\t return originalExpression.apply(undefined, _toConsumableArray(args));\n\t };\n\t watchExpression.displayName = 'Formly Watch Expression for field for ' + field.key;\n\t })();\n\t } else if (field.model) {\n\t watchExpression = $parse(watchExpression).bind(null, $scope, { model: field.model });\n\t }\n\t return watchExpression;\n\t }\n\t\n\t function getWatchListener(watcher, field, index) {\n\t var watchListener = watcher.listener;\n\t if (_angularFix2['default'].isFunction(watchListener) || watcher.runFieldExpressions) {\n\t (function () {\n\t // wrap the field's watch listener so we can call it with the field as the first arg\n\t // and the stop function as the last arg as a helper\n\t var originalListener = watchListener;\n\t watchListener = function formlyWatchListener() {\n\t var value = undefined;\n\t if (originalListener) {\n\t var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));\n\t value = originalListener.apply(undefined, _toConsumableArray(args));\n\t }\n\t if (watcher.runFieldExpressions) {\n\t runFieldExpressionProperties(field, index);\n\t }\n\t return value;\n\t };\n\t watchListener.displayName = 'Formly Watch Listener for field for ' + field.key;\n\t })();\n\t }\n\t return watchListener;\n\t }\n\t\n\t function modifyArgs(watcher, index) {\n\t for (var _len = arguments.length, originalArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n\t originalArgs[_key - 2] = arguments[_key];\n\t }\n\t\n\t return [$scope.fields[index]].concat(originalArgs, [watcher.stopWatching]);\n\t }\n\t\n\t function evalCloseToFormlyExpression(expression, val, field, index) {\n\t var extraLocals = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];\n\t\n\t extraLocals = _angularFix2['default'].extend(getFormlyFieldLikeLocals(field, index), extraLocals);\n\t return formlyUtil.formlyEval($scope, expression, val, val, extraLocals);\n\t }\n\t\n\t function getFormlyFieldLikeLocals(field, index) {\n\t // this makes it closer to what a regular formlyExpression would be\n\t return {\n\t model: field.model,\n\t options: field,\n\t index: index,\n\t formState: $scope.options.formState,\n\t originalModel: $scope.model,\n\t formOptions: $scope.options,\n\t formId: $scope.formId\n\t };\n\t }\n\t }\n\t\n\t function formlyFormLink(scope, el, attrs) {\n\t setFormController();\n\t fixChromeAutocomplete();\n\t\n\t function setFormController() {\n\t var formId = attrs.name;\n\t scope.formId = formId;\n\t scope.theFormlyForm = scope[formId];\n\t if (attrs.form) {\n\t var getter = $parse(attrs.form);\n\t var setter = getter.assign;\n\t var parentForm = getter(scope.$parent);\n\t if (parentForm) {\n\t scope.theFormlyForm = parentForm;\n\t if (scope[formId]) {\n\t scope.theFormlyForm.$removeControl(scope[formId]);\n\t }\n\t\n\t // this next line is probably one of the more dangerous things that angular-formly does to improve the\n\t // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be\n\t // attached to the form that is passed to formly-form rather than the one that formly-form creates\n\t // this is necessary because it's confusing to have a step between the form you pass in\n\t // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down\n\t // to children forms :-( This line was added to solve this issue:\n\t // https://github.com/formly-js/angular-formly/issues/287\n\t // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0\n\t // so I expect it will remain this way for the life of angular 1.x\n\t el.removeData('$formController');\n\t } else {\n\t setter(scope.$parent, scope[formId]);\n\t }\n\t }\n\t if (!scope.theFormlyForm && !formlyConfig.disableWarnings) {\n\t /* eslint no-console:0 */\n\t formlyWarn('formly-form-has-no-formcontroller', 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work', el, scope);\n\t }\n\t }\n\t\n\t /*\n\t * chrome autocomplete lameness\n\t * see https://code.google.com/p/chromium/issues/detail?id=468153#c14\n\t * ლ(ಠ益ಠლ) (╯°□°)╯︵ ┻━┻ (◞‸◟；)\n\t */\n\t function fixChromeAutocomplete() {\n\t var global = formlyConfig.extras.removeChromeAutoComplete === true;\n\t var offInstance = scope.options && scope.options.removeChromeAutoComplete === false;\n\t var onInstance = scope.options && scope.options.removeChromeAutoComplete === true;\n\t if (global && !offInstance || onInstance) {\n\t var input = document.createElement('input');\n\t input.setAttribute('autocomplete', 'address-level4');\n\t input.setAttribute('hidden', 'true');\n\t el[0].appendChild(input);\n\t }\n\t }\n\t }\n\t\n\t // stateless util functions\n\t function toKebabCase(string) {\n\t if (string) {\n\t return string.replace(/([A-Z])/g, function ($1) {\n\t return '-' + $1.toLowerCase();\n\t });\n\t } else {\n\t return '';\n\t }\n\t }\n\t\n\t function isFieldGroup(field) {\n\t return field && !!field.fieldGroup;\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\tvar _providersFormlyApiCheck = __webpack_require__(10);\n\t\n\tvar _providersFormlyApiCheck2 = _interopRequireDefault(_providersFormlyApiCheck);\n\t\n\tvar _otherDocsBaseUrl = __webpack_require__(3);\n\t\n\tvar _otherDocsBaseUrl2 = _interopRequireDefault(_otherDocsBaseUrl);\n\t\n\tvar _providersFormlyUsability = __webpack_require__(12);\n\t\n\tvar _providersFormlyUsability2 = _interopRequireDefault(_providersFormlyUsability);\n\t\n\tvar _providersFormlyConfig = __webpack_require__(11);\n\t\n\tvar _providersFormlyConfig2 = _interopRequireDefault(_providersFormlyConfig);\n\t\n\tvar _providersFormlyValidationMessages = __webpack_require__(13);\n\t\n\tvar _providersFormlyValidationMessages2 = _interopRequireDefault(_providersFormlyValidationMessages);\n\t\n\tvar _servicesFormlyUtil = __webpack_require__(16);\n\t\n\tvar _servicesFormlyUtil2 = _interopRequireDefault(_servicesFormlyUtil);\n\t\n\tvar _servicesFormlyWarn = __webpack_require__(17);\n\t\n\tvar _servicesFormlyWarn2 = _interopRequireDefault(_servicesFormlyWarn);\n\t\n\tvar _directivesFormlyCustomValidation = __webpack_require__(5);\n\t\n\tvar _directivesFormlyCustomValidation2 = _interopRequireDefault(_directivesFormlyCustomValidation);\n\t\n\tvar _directivesFormlyField = __webpack_require__(6);\n\t\n\tvar _directivesFormlyField2 = _interopRequireDefault(_directivesFormlyField);\n\t\n\tvar _directivesFormlyFocus = __webpack_require__(7);\n\t\n\tvar _directivesFormlyFocus2 = _interopRequireDefault(_directivesFormlyFocus);\n\t\n\tvar _directivesFormlyForm = __webpack_require__(8);\n\t\n\tvar _directivesFormlyForm2 = _interopRequireDefault(_directivesFormlyForm);\n\t\n\tvar _runFormlyNgModelAttrsManipulator = __webpack_require__(15);\n\t\n\tvar _runFormlyNgModelAttrsManipulator2 = _interopRequireDefault(_runFormlyNgModelAttrsManipulator);\n\t\n\tvar _runFormlyCustomTags = __webpack_require__(14);\n\t\n\tvar _runFormlyCustomTags2 = _interopRequireDefault(_runFormlyCustomTags);\n\t\n\tvar ngModuleName = 'formly';\n\t\n\texports['default'] = ngModuleName;\n\t\n\tvar ngModule = _angularFix2['default'].module(ngModuleName, []);\n\t\n\tngModule.constant('formlyApiCheck', _providersFormlyApiCheck2['default']);\n\tngModule.constant('formlyErrorAndWarningsUrlPrefix', _otherDocsBaseUrl2['default']);\n\tngModule.constant('formlyVersion', (\"8.1.0\")); // <-- webpack variable\n\t\n\tngModule.provider('formlyUsability', _providersFormlyUsability2['default']);\n\tngModule.provider('formlyConfig', _providersFormlyConfig2['default']);\n\t\n\tngModule.factory('formlyValidationMessages', _providersFormlyValidationMessages2['default']);\n\tngModule.factory('formlyUtil', _servicesFormlyUtil2['default']);\n\tngModule.factory('formlyWarn', _servicesFormlyWarn2['default']);\n\t\n\tngModule.directive('formlyCustomValidation', _directivesFormlyCustomValidation2['default']);\n\tngModule.directive('formlyField', _directivesFormlyField2['default']);\n\tngModule.directive('formlyFocus', _directivesFormlyFocus2['default']);\n\tngModule.directive('formlyForm', _directivesFormlyForm2['default']);\n\t\n\tngModule.run(_runFormlyNgModelAttrsManipulator2['default']);\n\tngModule.run(_runFormlyCustomTags2['default']);\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\tvar _apiCheck = __webpack_require__(4);\n\t\n\tvar _apiCheck2 = _interopRequireDefault(_apiCheck);\n\t\n\tvar apiCheck = (0, _apiCheck2['default'])({\n\t output: {\n\t prefix: 'angular-formly:',\n\t docsBaseUrl: __webpack_require__(3)\n\t }\n\t});\n\t\n\tfunction shapeRequiredIfNot(otherProps, propChecker) {\n\t if (!_angularFix2['default'].isArray(otherProps)) {\n\t otherProps = [otherProps];\n\t }\n\t var type = 'specified if these are not specified: `' + otherProps.join(', ') + '` (otherwise it\\'s optional)';\n\t\n\t function shapeRequiredIfNotDefinition(prop, propName, location, obj) {\n\t var propExists = obj && obj.hasOwnProperty(propName);\n\t var otherPropsExist = otherProps.some(function (otherProp) {\n\t return obj && obj.hasOwnProperty(otherProp);\n\t });\n\t if (!otherPropsExist && !propExists) {\n\t return apiCheck.utils.getError(propName, location, type);\n\t } else if (propExists) {\n\t return propChecker(prop, propName, location, obj);\n\t }\n\t }\n\t\n\t shapeRequiredIfNotDefinition.type = type;\n\t return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition);\n\t}\n\t\n\tvar formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func]);\n\tvar specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable;\n\t\n\tvar apiCheckProperty = apiCheck.func;\n\t\n\tvar apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({\n\t warn: apiCheck.func,\n\t 'throw': apiCheck.func,\n\t shape: apiCheck.func\n\t}));\n\t\n\tvar apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn']));\n\t\n\tvar formlyWrapperType = apiCheck.shape({\n\t name: shapeRequiredIfNot('types', apiCheck.string).optional,\n\t template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional,\n\t templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional,\n\t types: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n\t overwriteOk: apiCheck.bool.optional,\n\t apiCheck: apiCheckProperty.optional,\n\t apiCheckInstance: apiCheckInstanceProperty.optional,\n\t apiCheckFunction: apiCheckFunctionProperty.optional,\n\t apiCheckOptions: apiCheck.object.optional\n\t}).strict;\n\t\n\tvar expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({\n\t expression: formlyExpression,\n\t message: formlyExpression.optional\n\t}).strict]));\n\t\n\tvar modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object]);\n\t\n\tvar templateManipulators = apiCheck.shape({\n\t preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,\n\t postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional\n\t}).strict.nullable;\n\t\n\tvar validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({\n\t expression: formlyExpression,\n\t message: formlyExpression.optional\n\t}).strict]));\n\t\n\tvar watcherChecker = apiCheck.typeOrArrayOf(apiCheck.shape({\n\t expression: formlyExpression.optional,\n\t listener: formlyExpression.optional,\n\t runFieldExpressions: apiCheck.bool.optional\n\t}));\n\t\n\tvar fieldOptionsApiShape = {\n\t $$hashKey: apiCheck.any.optional,\n\t type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional,\n\t template: apiCheck.shape.ifNot(['type', 'templateUrl'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n\t templateUrl: apiCheck.shape.ifNot(['type', 'template'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n\t key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n\t model: modelChecker.optional,\n\t originalModel: modelChecker.optional,\n\t className: apiCheck.string.optional,\n\t id: apiCheck.string.optional,\n\t name: apiCheck.string.optional,\n\t expressionProperties: expressionProperties.optional,\n\t extras: apiCheck.shape({\n\t validateOnModelChange: apiCheck.bool.optional,\n\t skipNgModelAttrsManipulator: apiCheck.oneOfType([apiCheck.string, apiCheck.bool]).optional\n\t }).strict.optional,\n\t data: apiCheck.object.optional,\n\t templateOptions: apiCheck.object.optional,\n\t wrapper: specifyWrapperType.optional,\n\t modelOptions: apiCheck.shape({\n\t updateOn: apiCheck.string.optional,\n\t debounce: apiCheck.oneOfType([apiCheck.objectOf(apiCheck.number), apiCheck.number]).optional,\n\t allowInvalid: apiCheck.bool.optional,\n\t getterSetter: apiCheck.bool.optional,\n\t timezone: apiCheck.string.optional\n\t }).optional,\n\t watcher: watcherChecker.optional,\n\t validators: validatorChecker.optional,\n\t asyncValidators: validatorChecker.optional,\n\t parsers: apiCheck.arrayOf(formlyExpression).optional,\n\t formatters: apiCheck.arrayOf(formlyExpression).optional,\n\t noFormControl: apiCheck.bool.optional,\n\t hide: apiCheck.bool.optional,\n\t hideExpression: formlyExpression.optional,\n\t ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional,\n\t ngModelAttrs: apiCheck.objectOf(apiCheck.shape({\n\t statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional,\n\t value: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n\t attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n\t bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n\t boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional\n\t }).strict).optional,\n\t elementAttributes: apiCheck.objectOf(apiCheck.string).optional,\n\t optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n\t link: apiCheck.func.optional,\n\t controller: apiCheck.oneOfType([apiCheck.string, apiCheck.func, apiCheck.array]).optional,\n\t validation: apiCheck.shape({\n\t show: apiCheck.bool.nullable.optional,\n\t messages: apiCheck.objectOf(formlyExpression).optional,\n\t errorExistsAndShouldBeVisible: apiCheck.bool.optional\n\t }).optional,\n\t formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional,\n\t value: apiCheck.func.optional,\n\t runExpressions: apiCheck.func.optional,\n\t templateManipulators: templateManipulators.optional,\n\t resetModel: apiCheck.func.optional,\n\t updateInitialValue: apiCheck.func.optional,\n\t initialValue: apiCheck.any.optional,\n\t defaultValue: apiCheck.any.optional\n\t};\n\t\n\tvar formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict;\n\t\n\tvar formOptionsApi = apiCheck.shape({\n\t formState: apiCheck.object.optional,\n\t resetModel: apiCheck.func.optional,\n\t updateInitialValue: apiCheck.func.optional,\n\t removeChromeAutoComplete: apiCheck.bool.optional,\n\t templateManipulators: templateManipulators.optional,\n\t manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional,\n\t watchAllExpressions: apiCheck.bool.optional,\n\t wrapper: specifyWrapperType.optional,\n\t fieldTransform: apiCheck.oneOfType([apiCheck.func, apiCheck.array]).optional,\n\t data: apiCheck.object.optional\n\t}).strict;\n\t\n\tvar fieldGroup = apiCheck.shape({\n\t $$hashKey: apiCheck.any.optional,\n\t key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n\t // danger. Nested field groups wont get api-checked...\n\t fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])),\n\t className: apiCheck.string.optional,\n\t options: formOptionsApi.optional,\n\t templateOptions: apiCheck.object.optional,\n\t wrapper: specifyWrapperType.optional,\n\t watcher: watcherChecker.optional,\n\t hide: apiCheck.bool.optional,\n\t hideExpression: formlyExpression.optional,\n\t data: apiCheck.object.optional,\n\t model: modelChecker.optional,\n\t form: apiCheck.object.optional,\n\t elementAttributes: apiCheck.objectOf(apiCheck.string).optional\n\t}).strict;\n\t\n\tvar typeOptionsDefaultOptions = _angularFix2['default'].copy(fieldOptionsApiShape);\n\ttypeOptionsDefaultOptions.key = apiCheck.string.optional;\n\t\n\tvar formlyTypeOptions = apiCheck.shape({\n\t name: apiCheck.string,\n\t template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n\t templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n\t controller: apiCheck.oneOfType([apiCheck.func, apiCheck.string, apiCheck.array]).optional,\n\t link: apiCheck.func.optional,\n\t defaultOptions: apiCheck.oneOfType([apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions)]).optional,\n\t 'extends': apiCheck.string.optional,\n\t wrapper: specifyWrapperType.optional,\n\t data: apiCheck.object.optional,\n\t apiCheck: apiCheckProperty.optional,\n\t apiCheckInstance: apiCheckInstanceProperty.optional,\n\t apiCheckFunction: apiCheckFunctionProperty.optional,\n\t apiCheckOptions: apiCheck.object.optional,\n\t overwriteOk: apiCheck.bool.optional\n\t}).strict;\n\t\n\t_angularFix2['default'].extend(apiCheck, {\n\t formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi\n\t});\n\t\n\texports['default'] = apiCheck;\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tformlyConfig.$inject = [\"formlyUsabilityProvider\", \"formlyErrorAndWarningsUrlPrefix\", \"formlyApiCheck\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\tvar _otherUtils = __webpack_require__(2);\n\t\n\tvar _otherUtils2 = _interopRequireDefault(_otherUtils);\n\t\n\texports['default'] = formlyConfig;\n\t\n\t// @ngInject\n\tfunction formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) {\n\t var _this2 = this;\n\t\n\t var typeMap = {};\n\t var templateWrappersMap = {};\n\t var defaultWrapperName = 'default';\n\t var _this = this;\n\t var getError = formlyUsabilityProvider.getFormlyError;\n\t\n\t _angularFix2['default'].extend(this, {\n\t setType: setType,\n\t getType: getType,\n\t getTypes: getTypes,\n\t getTypeHeritage: getTypeHeritage,\n\t setWrapper: setWrapper,\n\t getWrapper: getWrapper,\n\t getWrapperByType: getWrapperByType,\n\t removeWrapperByName: removeWrapperByName,\n\t removeWrappersForType: removeWrappersForType,\n\t disableWarnings: false,\n\t extras: {\n\t disableNgModelAttrsManipulator: false,\n\t fieldTransform: [],\n\t ngModelAttrsManipulatorPreferUnbound: false,\n\t removeChromeAutoComplete: false,\n\t defaultHideDirective: 'ng-if',\n\t getFieldId: null\n\t },\n\t templateManipulators: {\n\t preWrapper: [],\n\t postWrapper: []\n\t },\n\t $get: function $get() {\n\t return _this2;\n\t }\n\t });\n\t\n\t function setType(options) {\n\t if (_angularFix2['default'].isArray(options)) {\n\t var _ret = (function () {\n\t var allTypes = [];\n\t _angularFix2['default'].forEach(options, function (item) {\n\t allTypes.push(setType(item));\n\t });\n\t return {\n\t v: allTypes\n\t };\n\t })();\n\t\n\t if (typeof _ret === 'object') return _ret.v;\n\t } else if (_angularFix2['default'].isObject(options)) {\n\t checkType(options);\n\t if (options['extends']) {\n\t extendTypeOptions(options);\n\t }\n\t typeMap[options.name] = options;\n\t return typeMap[options.name];\n\t } else {\n\t throw getError('You must provide an object or array for setType. You provided: ' + JSON.stringify(arguments));\n\t }\n\t }\n\t\n\t function checkType(options) {\n\t formlyApiCheck['throw'](formlyApiCheck.formlyTypeOptions, options, {\n\t prefix: 'formlyConfig.setType',\n\t url: 'settype-validation-failed'\n\t });\n\t if (!options.overwriteOk) {\n\t checkOverwrite(options.name, typeMap, options, 'types');\n\t } else {\n\t options.overwriteOk = undefined;\n\t }\n\t }\n\t\n\t function extendTypeOptions(options) {\n\t var extendsType = getType(options['extends'], true, options);\n\t extendTypeControllerFunction(options, extendsType);\n\t extendTypeLinkFunction(options, extendsType);\n\t extendTypeDefaultOptions(options, extendsType);\n\t _otherUtils2['default'].reverseDeepMerge(options, extendsType);\n\t extendTemplate(options, extendsType);\n\t }\n\t\n\t function extendTemplate(options, extendsType) {\n\t if (options.template && extendsType.templateUrl) {\n\t delete options.templateUrl;\n\t } else if (options.templateUrl && extendsType.template) {\n\t delete options.template;\n\t }\n\t }\n\t\n\t function extendTypeControllerFunction(options, extendsType) {\n\t var extendsCtrl = extendsType.controller;\n\t if (!_angularFix2['default'].isDefined(extendsCtrl)) {\n\t return;\n\t }\n\t var optionsCtrl = options.controller;\n\t if (_angularFix2['default'].isDefined(optionsCtrl)) {\n\t options.controller = function ($scope, $controller) {\n\t $controller(extendsCtrl, { $scope: $scope });\n\t $controller(optionsCtrl, { $scope: $scope });\n\t };\n\t options.controller.$inject = ['$scope', '$controller'];\n\t } else {\n\t options.controller = extendsCtrl;\n\t }\n\t }\n\t\n\t function extendTypeLinkFunction(options, extendsType) {\n\t var extendsFn = extendsType.link;\n\t if (!_angularFix2['default'].isDefined(extendsFn)) {\n\t return;\n\t }\n\t var optionsFn = options.link;\n\t if (_angularFix2['default'].isDefined(optionsFn)) {\n\t options.link = function () {\n\t extendsFn.apply(undefined, arguments);\n\t optionsFn.apply(undefined, arguments);\n\t };\n\t } else {\n\t options.link = extendsFn;\n\t }\n\t }\n\t\n\t function extendTypeDefaultOptions(options, extendsType) {\n\t var extendsDO = extendsType.defaultOptions;\n\t if (!_angularFix2['default'].isDefined(extendsDO)) {\n\t return;\n\t }\n\t var optionsDO = options.defaultOptions;\n\t var optionsDOIsFn = _angularFix2['default'].isFunction(optionsDO);\n\t var extendsDOIsFn = _angularFix2['default'].isFunction(extendsDO);\n\t if (extendsDOIsFn) {\n\t options.defaultOptions = function defaultOptions(opts, scope) {\n\t var extendsDefaultOptions = extendsDO(opts, scope);\n\t var mergedDefaultOptions = {};\n\t _otherUtils2['default'].reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions);\n\t var extenderOptionsDefaultOptions = optionsDO;\n\t if (optionsDOIsFn) {\n\t extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope);\n\t }\n\t _otherUtils2['default'].reverseDeepMerge(extendsDefaultOptions, extenderOptionsDefaultOptions);\n\t return extendsDefaultOptions;\n\t };\n\t } else if (optionsDOIsFn) {\n\t options.defaultOptions = function defaultOptions(opts, scope) {\n\t var newDefaultOptions = {};\n\t _otherUtils2['default'].reverseDeepMerge(newDefaultOptions, opts, extendsDO);\n\t return optionsDO(newDefaultOptions, scope);\n\t };\n\t }\n\t }\n\t\n\t function getType(name, throwError, errorContext) {\n\t if (!name) {\n\t return undefined;\n\t }\n\t var type = typeMap[name];\n\t if (!type && throwError === true) {\n\t throw getError('There is no type by the name of \"' + name + '\": ' + JSON.stringify(errorContext));\n\t } else {\n\t return type;\n\t }\n\t }\n\t\n\t function getTypes() {\n\t return typeMap;\n\t }\n\t\n\t function getTypeHeritage(parent) {\n\t var heritage = [];\n\t var type = parent;\n\t if (_angularFix2['default'].isString(type)) {\n\t type = getType(parent);\n\t }\n\t parent = type['extends'];\n\t while (parent) {\n\t type = getType(parent);\n\t heritage.push(type);\n\t parent = type['extends'];\n\t }\n\t return heritage;\n\t }\n\t\n\t function setWrapper(_x, _x2) {\n\t var _again = true;\n\t\n\t _function: while (_again) {\n\t var options = _x,\n\t name = _x2;\n\t _again = false;\n\t\n\t if (_angularFix2['default'].isArray(options)) {\n\t return options.map(function (wrapperOptions) {\n\t return setWrapper(wrapperOptions);\n\t });\n\t } else if (_angularFix2['default'].isObject(options)) {\n\t options.types = getOptionsTypes(options);\n\t options.name = getOptionsName(options, name);\n\t checkWrapperAPI(options);\n\t templateWrappersMap[options.name] = options;\n\t return options;\n\t } else if (_angularFix2['default'].isString(options)) {\n\t _x = {\n\t template: options,\n\t name: name\n\t };\n\t _x2 = undefined;\n\t _again = true;\n\t continue _function;\n\t }\n\t }\n\t }\n\t\n\t function getOptionsTypes(options) {\n\t if (_angularFix2['default'].isString(options.types)) {\n\t return [options.types];\n\t }\n\t if (!_angularFix2['default'].isDefined(options.types)) {\n\t return [];\n\t } else {\n\t return options.types;\n\t }\n\t }\n\t\n\t function getOptionsName(options, name) {\n\t return options.name || name || options.types.join(' ') || defaultWrapperName;\n\t }\n\t\n\t function checkWrapperAPI(options) {\n\t formlyUsabilityProvider.checkWrapper(options);\n\t if (options.template) {\n\t formlyUsabilityProvider.checkWrapperTemplate(options.template, options);\n\t }\n\t if (!options.overwriteOk) {\n\t checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers');\n\t } else {\n\t delete options.overwriteOk;\n\t }\n\t checkWrapperTypes(options);\n\t }\n\t\n\t function checkWrapperTypes(options) {\n\t var shouldThrow = !_angularFix2['default'].isArray(options.types) || !options.types.every(_angularFix2['default'].isString);\n\t if (shouldThrow) {\n\t throw getError('Attempted to create a template wrapper with types that is not a string or an array of strings');\n\t }\n\t }\n\t\n\t function checkOverwrite(property, object, newValue, objectName) {\n\t if (object.hasOwnProperty(property)) {\n\t warn('overwriting-types-or-wrappers', ['Attempting to overwrite ' + property + ' on ' + objectName + ' which is currently', JSON.stringify(object[property]) + ' with ' + JSON.stringify(newValue), 'To supress this warning, specify the property \"overwriteOk: true\"'].join(' '));\n\t }\n\t }\n\t\n\t function getWrapper(name) {\n\t return templateWrappersMap[name || defaultWrapperName];\n\t }\n\t\n\t function getWrapperByType(type) {\n\t /* eslint prefer-const:0 */\n\t var wrappers = [];\n\t for (var _name in templateWrappersMap) {\n\t if (templateWrappersMap.hasOwnProperty(_name)) {\n\t if (templateWrappersMap[_name].types && templateWrappersMap[_name].types.indexOf(type) !== -1) {\n\t wrappers.push(templateWrappersMap[_name]);\n\t }\n\t }\n\t }\n\t return wrappers;\n\t }\n\t\n\t function removeWrapperByName(name) {\n\t var wrapper = templateWrappersMap[name];\n\t delete templateWrappersMap[name];\n\t return wrapper;\n\t }\n\t\n\t function removeWrappersForType(type) {\n\t var wrappers = getWrapperByType(type);\n\t if (!wrappers) {\n\t return undefined;\n\t }\n\t if (!_angularFix2['default'].isArray(wrappers)) {\n\t return removeWrapperByName(wrappers.name);\n\t } else {\n\t wrappers.forEach(function (wrapper) {\n\t return removeWrapperByName(wrapper.name);\n\t });\n\t return wrappers;\n\t }\n\t }\n\t\n\t function warn() {\n\t if (!_this.disableWarnings && console.warn) {\n\t /* eslint no-console:0 */\n\t var args = Array.prototype.slice.call(arguments);\n\t var warnInfoSlug = args.shift();\n\t args.unshift('Formly Warning:');\n\t args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);\n\t console.warn.apply(console, _toConsumableArray(args));\n\t }\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tformlyUsability.$inject = [\"formlyApiCheck\", \"formlyErrorAndWarningsUrlPrefix\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\texports['default'] = formlyUsability;\n\t\n\t// @ngInject\n\tfunction formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {\n\t var _this = this;\n\t\n\t _angularFix2['default'].extend(this, {\n\t getFormlyError: getFormlyError,\n\t getFieldError: getFieldError,\n\t checkWrapper: checkWrapper,\n\t checkWrapperTemplate: checkWrapperTemplate,\n\t getErrorMessage: getErrorMessage,\n\t $get: function $get() {\n\t return _this;\n\t }\n\t });\n\t\n\t function getFieldError(errorInfoSlug, message, field) {\n\t if (arguments.length < 3) {\n\t field = message;\n\t message = errorInfoSlug;\n\t errorInfoSlug = null;\n\t }\n\t return new Error(getErrorMessage(errorInfoSlug, message) + (' Field definition: ' + _angularFix2['default'].toJson(field)));\n\t }\n\t\n\t function getFormlyError(errorInfoSlug, message) {\n\t if (!message) {\n\t message = errorInfoSlug;\n\t errorInfoSlug = null;\n\t }\n\t return new Error(getErrorMessage(errorInfoSlug, message));\n\t }\n\t\n\t function getErrorMessage(errorInfoSlug, message) {\n\t var url = '';\n\t if (errorInfoSlug !== null) {\n\t url = '' + formlyErrorAndWarningsUrlPrefix + errorInfoSlug;\n\t }\n\t return 'Formly Error: ' + message + '. ' + url;\n\t }\n\t\n\t function checkWrapper(wrapper) {\n\t formlyApiCheck['throw'](formlyApiCheck.formlyWrapperType, wrapper, {\n\t prefix: 'formlyConfig.setWrapper',\n\t urlSuffix: 'setwrapper-validation-failed'\n\t });\n\t }\n\t\n\t function checkWrapperTemplate(template, additionalInfo) {\n\t var formlyTransclude = '';\n\t if (template.indexOf(formlyTransclude) === -1) {\n\t throw getFormlyError('Template wrapper templates must use \"' + formlyTransclude + '\" somewhere in them. ' + ('This one does not have \"\" in it: ' + template) + '\\n' + ('Additional information: ' + JSON.stringify(additionalInfo)));\n\t }\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 13 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\texports['default'] = formlyValidationMessages;\n\t\n\t// @ngInject\n\tfunction formlyValidationMessages() {\n\t\n\t var validationMessages = {\n\t addTemplateOptionValueMessage: addTemplateOptionValueMessage,\n\t addStringMessage: addStringMessage,\n\t messages: {}\n\t };\n\t\n\t return validationMessages;\n\t\n\t function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) {\n\t validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate);\n\t }\n\t\n\t function addStringMessage(name, string) {\n\t validationMessages.messages[name] = function () {\n\t return string;\n\t };\n\t }\n\t\n\t function templateOptionValue(prop, prefix, suffix, alternate) {\n\t return function getValidationMessage(viewValue, modelValue, scope) {\n\t if (typeof scope.options.templateOptions[prop] !== 'undefined') {\n\t return prefix + ' ' + scope.options.templateOptions[prop] + ' ' + suffix;\n\t } else {\n\t return alternate;\n\t }\n\t };\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\taddCustomTags.$inject = [\"$document\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\texports['default'] = addCustomTags;\n\t\n\t// @ngInject\n\tfunction addCustomTags($document) {\n\t // IE8 check ->\n\t // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx\n\t if ($document && $document.documentMode < 9) {\n\t (function () {\n\t var document = $document.get(0);\n\t // add the custom elements that we need for formly\n\t var customElements = ['formly-field', 'formly-form'];\n\t _angularFix2['default'].forEach(customElements, function (el) {\n\t document.createElement(el);\n\t });\n\t })();\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\taddFormlyNgModelAttrsManipulator.$inject = [\"formlyConfig\", \"$interpolate\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _angularFix = __webpack_require__(1);\n\t\n\tvar _angularFix2 = _interopRequireDefault(_angularFix);\n\t\n\tvar _otherUtils = __webpack_require__(2);\n\t\n\texports['default'] = addFormlyNgModelAttrsManipulator;\n\t\n\t// @ngInject\n\tfunction addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) {\n\t if (formlyConfig.extras.disableNgModelAttrsManipulator) {\n\t return;\n\t }\n\t formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator);\n\t\n\t function ngModelAttrsManipulator(template, options, scope) {\n\t var node = document.createElement('div');\n\t var skip = options.extras && options.extras.skipNgModelAttrsManipulator;\n\t if (skip === true) {\n\t return template;\n\t }\n\t node.innerHTML = template;\n\t\n\t var modelNodes = getNgModelNodes(node, skip);\n\t if (!modelNodes || !modelNodes.length) {\n\t return template;\n\t }\n\t\n\t addIfNotPresent(modelNodes, 'id', scope.id);\n\t addIfNotPresent(modelNodes, 'name', scope.name || scope.id);\n\t\n\t addValidation();\n\t alterNgModelAttr();\n\t addModelOptions();\n\t addTemplateOptionsAttrs();\n\t addNgModelElAttrs();\n\t\n\t return node.innerHTML;\n\t\n\t function addValidation() {\n\t if (_angularFix2['default'].isDefined(options.validators) || _angularFix2['default'].isDefined(options.validation.messages)) {\n\t addIfNotPresent(modelNodes, 'formly-custom-validation', '');\n\t }\n\t }\n\t\n\t function alterNgModelAttr() {\n\t if (isPropertyAccessor(options.key)) {\n\t addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key);\n\t }\n\t }\n\t\n\t function addModelOptions() {\n\t if (_angularFix2['default'].isDefined(options.modelOptions)) {\n\t addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions');\n\t if (options.modelOptions.getterSetter) {\n\t addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value');\n\t }\n\t }\n\t }\n\t\n\t function addTemplateOptionsAttrs() {\n\t if (!options.templateOptions && !options.expressionProperties) {\n\t // no need to run these if there are no templateOptions or expressionProperties\n\t return;\n\t }\n\t var to = options.templateOptions || {};\n\t var ep = options.expressionProperties || {};\n\t\n\t var ngModelAttributes = getBuiltInAttributes();\n\t\n\t // extend with the user's specifications winning\n\t _angularFix2['default'].extend(ngModelAttributes, options.ngModelAttrs);\n\t\n\t // Feel free to make this more simple :-)\n\t _angularFix2['default'].forEach(ngModelAttributes, function (val, name) {\n\t /* eslint complexity:[2, 14] */\n\t var attrVal = undefined,\n\t attrName = undefined;\n\t var ref = 'options.templateOptions[\\'' + name + '\\']';\n\t var toVal = to[name];\n\t var epVal = getEpValue(ep, name);\n\t\n\t var inTo = _angularFix2['default'].isDefined(toVal);\n\t var inEp = _angularFix2['default'].isDefined(epVal);\n\t if (val.value) {\n\t // I realize this looks backwards, but it's right, trust me...\n\t attrName = val.value;\n\t attrVal = name;\n\t } else if (val.statement && inTo) {\n\t attrName = val.statement;\n\t if (_angularFix2['default'].isString(to[name])) {\n\t attrVal = '$eval(' + ref + ')';\n\t } else if (_angularFix2['default'].isFunction(to[name])) {\n\t attrVal = ref + '(model[options.key], options, this, $event)';\n\t } else {\n\t throw new Error('options.templateOptions.' + name + ' must be a string or function: ' + JSON.stringify(options));\n\t }\n\t } else if (val.bound && inEp) {\n\t attrName = val.bound;\n\t attrVal = ref;\n\t } else if ((val.attribute || val.boolean) && inEp) {\n\t attrName = val.attribute || val.boolean;\n\t attrVal = '' + $interpolate.startSymbol() + ref + $interpolate.endSymbol();\n\t } else if (val.attribute && inTo) {\n\t attrName = val.attribute;\n\t attrVal = toVal;\n\t } else if (val.boolean) {\n\t if (inTo && !inEp && toVal) {\n\t attrName = val.boolean;\n\t attrVal = true;\n\t } else {\n\t /* eslint no-empty:0 */\n\t // empty to illustrate that a boolean will not be added via val.bound\n\t // if you want it added via val.bound, then put it in expressionProperties\n\t }\n\t } else if (val.bound && inTo) {\n\t attrName = val.bound;\n\t attrVal = ref;\n\t }\n\t\n\t if (_angularFix2['default'].isDefined(attrName) && _angularFix2['default'].isDefined(attrVal)) {\n\t addIfNotPresent(modelNodes, attrName, attrVal);\n\t }\n\t });\n\t }\n\t\n\t function addNgModelElAttrs() {\n\t _angularFix2['default'].forEach(options.ngModelElAttrs, function (val, name) {\n\t addRegardlessOfPresence(modelNodes, name, val);\n\t });\n\t }\n\t }\n\t\n\t // Utility functions\n\t function getNgModelNodes(node, skip) {\n\t var selectorNot = _angularFix2['default'].isString(skip) ? ':not(' + skip + ')' : '';\n\t var skipNot = ':not([formly-skip-ng-model-attrs-manipulator])';\n\t var query = '[ng-model]' + selectorNot + skipNot + ', [data-ng-model]' + selectorNot + skipNot;\n\t try {\n\t return node.querySelectorAll(query);\n\t } catch (e) {\n\t //this code is needed for IE8, as it does not support the CSS3 ':not' selector\n\t //it should be removed when IE8 support is dropped\n\t return getNgModelNodesFallback(node, skip);\n\t }\n\t }\n\t\n\t function getNgModelNodesFallback(node, skip) {\n\t var allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]');\n\t var matchingNgModelNodes = [];\n\t\n\t //make sure this array is compatible with NodeList type by adding an 'item' function\n\t matchingNgModelNodes.item = function (i) {\n\t return this[i];\n\t };\n\t\n\t for (var i = 0; i < allNgModelNodes.length; i++) {\n\t var ngModelNode = allNgModelNodes[i];\n\t if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') && !(_angularFix2['default'].isString(skip) && nodeMatches(ngModelNode, skip))) {\n\t matchingNgModelNodes.push(ngModelNode);\n\t }\n\t }\n\t\n\t return matchingNgModelNodes;\n\t }\n\t\n\t function nodeMatches(node, selector) {\n\t var div = document.createElement('div');\n\t div.innerHTML = node.outerHTML;\n\t return div.querySelector(selector);\n\t }\n\t\n\t function getBuiltInAttributes() {\n\t var ngModelAttributes = {\n\t focus: {\n\t attribute: 'formly-focus'\n\t }\n\t };\n\t var boundOnly = [];\n\t var bothBooleanAndBound = ['required', 'disabled'];\n\t var bothAttributeAndBound = ['pattern', 'minlength'];\n\t var statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur'];\n\t var attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type'];\n\t if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {\n\t bothAttributeAndBound.push('maxlength');\n\t } else {\n\t boundOnly.push('maxlength');\n\t }\n\t\n\t _angularFix2['default'].forEach(boundOnly, function (item) {\n\t ngModelAttributes[item] = { bound: 'ng-' + item };\n\t });\n\t\n\t _angularFix2['default'].forEach(bothBooleanAndBound, function (item) {\n\t ngModelAttributes[item] = { boolean: item, bound: 'ng-' + item };\n\t });\n\t\n\t _angularFix2['default'].forEach(bothAttributeAndBound, function (item) {\n\t ngModelAttributes[item] = { attribute: item, bound: 'ng-' + item };\n\t });\n\t\n\t _angularFix2['default'].forEach(statementOnly, function (item) {\n\t var propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1);\n\t ngModelAttributes[propName] = { statement: 'ng-' + item };\n\t });\n\t\n\t _angularFix2['default'].forEach(attributeOnly, function (item) {\n\t ngModelAttributes[item] = { attribute: item };\n\t });\n\t return ngModelAttributes;\n\t }\n\t\n\t function getEpValue(ep, name) {\n\t return ep['templateOptions.' + name] || ep['templateOptions[\\'' + name + '\\']'] || ep['templateOptions[\"' + name + '\"]'];\n\t }\n\t\n\t function addIfNotPresent(nodes, attr, val) {\n\t _angularFix2['default'].forEach(nodes, function (node) {\n\t if (!node.getAttribute(attr)) {\n\t node.setAttribute(attr, val);\n\t }\n\t });\n\t }\n\t\n\t function addRegardlessOfPresence(nodes, attr, val) {\n\t _angularFix2['default'].forEach(nodes, function (node) {\n\t node.setAttribute(attr, val);\n\t });\n\t }\n\t\n\t function isPropertyAccessor(key) {\n\t return (0, _otherUtils.contains)(key, '.') || (0, _otherUtils.contains)(key, '[') && (0, _otherUtils.contains)(key, ']');\n\t }\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 16 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\t\n\tvar _otherUtils = __webpack_require__(2);\n\t\n\tvar _otherUtils2 = _interopRequireDefault(_otherUtils);\n\t\n\texports['default'] = formlyUtil;\n\t\n\t// @ngInject\n\tfunction formlyUtil() {\n\t return _otherUtils2['default'];\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 17 */\n/***/ function(module, exports) {\n\n\t'use strict';\n\t\n\tformlyWarn.$inject = [\"formlyConfig\", \"formlyErrorAndWarningsUrlPrefix\", \"$log\"];\n\tObject.defineProperty(exports, '__esModule', {\n\t value: true\n\t});\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\t\n\texports['default'] = formlyWarn;\n\t\n\t// @ngInject\n\tfunction formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) {\n\t return function warn() {\n\t if (!formlyConfig.disableWarnings) {\n\t var args = Array.prototype.slice.call(arguments);\n\t var warnInfoSlug = args.shift();\n\t args.unshift('Formly Warning:');\n\t args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);\n\t $log.warn.apply($log, _toConsumableArray(args));\n\t }\n\t };\n\t}\n\tmodule.exports = exports['default'];\n\n/***/ },\n/* 18 */\n/***/ function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_18__;\n\n/***/ }\n/******/ ])\n});\n;\n\n\n/** WEBPACK FOOTER **\n ** dist/formly.min.js\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 19ac0e0f47f310ea6197\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _indexCommon = require('./index.common');\n\nvar _indexCommon2 = _interopRequireDefault(_indexCommon);\n\nexports['default'] = _indexCommon2['default'];\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./index.js\n **/","import index from './index.common'\nexport default index\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./index.js\n **/","// some versions of angular don't export the angular module properly,\n// so we get it from window in this case.\n'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\nvar angular = require('angular');\n\n/* istanbul ignore next */\nif (!angular.version) {\n angular = window.angular;\n}\nexports['default'] = angular;\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./angular-fix/index.js\n **/","// some versions of angular don't export the angular module properly,\n// so we get it from window in this case.\nlet angular = require('angular')\n\n/* istanbul ignore next */\nif (!angular.version) {\n angular = window.angular\n}\nexport default angular\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./angular-fix/index.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nexports['default'] = {\n containsSelector: containsSelector, containsSpecialChar: containsSpecialChar, formlyEval: formlyEval, getFieldId: getFieldId, reverseDeepMerge: reverseDeepMerge, findByNodeName: findByNodeName,\n arrayify: arrayify, extendFunction: extendFunction, extendArray: extendArray, startsWith: startsWith, contains: contains\n};\n\nfunction containsSelector(string) {\n return containsSpecialChar(string, '.') || containsSpecialChar(string, '[') && containsSpecialChar(string, ']');\n}\n\nfunction containsSpecialChar(a, b) {\n if (!a || !a.indexOf) {\n return false;\n }\n return a.indexOf(b) !== -1;\n}\n\nfunction formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {\n if (_angularFix2['default'].isFunction(expression)) {\n return expression($viewValue, $modelValue, scope, extraLocals);\n } else {\n return scope.$eval(expression, _angularFix2['default'].extend({ $viewValue: $viewValue, $modelValue: $modelValue }, extraLocals));\n }\n}\n\nfunction getFieldId(formId, options, index) {\n if (options.id) {\n return options.id;\n }\n var type = options.type;\n if (!type && options.template) {\n type = 'template';\n } else if (!type && options.templateUrl) {\n type = 'templateUrl';\n }\n\n return [formId, type, options.key, index].join('_');\n}\n\nfunction reverseDeepMerge(dest) {\n _angularFix2['default'].forEach(arguments, function (src, index) {\n if (!index) {\n return;\n }\n _angularFix2['default'].forEach(src, function (val, prop) {\n if (!_angularFix2['default'].isDefined(dest[prop])) {\n dest[prop] = _angularFix2['default'].copy(val);\n } else if (objAndSameType(dest[prop], val)) {\n reverseDeepMerge(dest[prop], val);\n }\n });\n });\n return dest;\n}\n\nfunction objAndSameType(obj1, obj2) {\n return _angularFix2['default'].isObject(obj1) && _angularFix2['default'].isObject(obj2) && Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2);\n}\n\n// recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8\nfunction findByNodeName(el, nodeName) {\n if (!el.prop) {\n // not a jQuery or jqLite object -> wrap it\n el = _angularFix2['default'].element(el);\n }\n\n if (el.prop('nodeName') === nodeName.toUpperCase()) {\n return el;\n }\n\n var c = el.children();\n for (var i = 0; c && i < c.length; i++) {\n var node = findByNodeName(c[i], nodeName);\n if (node) {\n return node;\n }\n }\n}\n\nfunction arrayify(obj) {\n if (obj && !_angularFix2['default'].isArray(obj)) {\n obj = [obj];\n } else if (!obj) {\n obj = [];\n }\n return obj;\n}\n\nfunction extendFunction() {\n for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {\n fns[_key] = arguments[_key];\n }\n\n return function extendedFunction() {\n var args = arguments;\n fns.forEach(function (fn) {\n return fn.apply(null, args);\n });\n };\n}\n\nfunction extendArray(primary, secondary, property) {\n if (property) {\n primary = primary[property];\n secondary = secondary[property];\n }\n if (secondary && primary) {\n _angularFix2['default'].forEach(secondary, function (item) {\n if (primary.indexOf(item) === -1) {\n primary.push(item);\n }\n });\n return primary;\n } else if (secondary) {\n return secondary;\n } else {\n return primary;\n }\n}\n\nfunction startsWith(str, search) {\n if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {\n return str.length >= search.length && str.substring(0, search.length) === search;\n } else {\n return false;\n }\n}\n\nfunction contains(str, search) {\n if (_angularFix2['default'].isString(str) && _angularFix2['default'].isString(search)) {\n return str.length >= search.length && str.indexOf(search) !== -1;\n } else {\n return false;\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./other/utils.js\n **/","import angular from 'angular-fix'\n\nexport default {\n containsSelector, containsSpecialChar, formlyEval, getFieldId, reverseDeepMerge, findByNodeName,\n arrayify, extendFunction, extendArray, startsWith, contains,\n}\n\nfunction containsSelector(string) {\n return containsSpecialChar(string, '.') || (containsSpecialChar(string, '[') && containsSpecialChar(string, ']'))\n}\n\nfunction containsSpecialChar(a, b) {\n if (!a || !a.indexOf) {\n return false\n }\n return a.indexOf(b) !== -1\n}\n\n\nfunction formlyEval(scope, expression, $modelValue, $viewValue, extraLocals) {\n if (angular.isFunction(expression)) {\n return expression($viewValue, $modelValue, scope, extraLocals)\n } else {\n return scope.$eval(expression, angular.extend({$viewValue, $modelValue}, extraLocals))\n }\n}\n\nfunction getFieldId(formId, options, index) {\n if (options.id) {\n return options.id\n }\n let type = options.type\n if (!type && options.template) {\n type = 'template'\n } else if (!type && options.templateUrl) {\n type = 'templateUrl'\n }\n\n return [formId, type, options.key, index].join('_')\n}\n\n\nfunction reverseDeepMerge(dest) {\n angular.forEach(arguments, (src, index) => {\n if (!index) {\n return\n }\n angular.forEach(src, (val, prop) => {\n if (!angular.isDefined(dest[prop])) {\n dest[prop] = angular.copy(val)\n } else if (objAndSameType(dest[prop], val)) {\n reverseDeepMerge(dest[prop], val)\n }\n })\n })\n return dest\n}\n\nfunction objAndSameType(obj1, obj2) {\n return angular.isObject(obj1) && angular.isObject(obj2) &&\n Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2)\n}\n\n// recurse down a node tree to find a node with matching nodeName, for custom tags jQuery.find doesn't work in IE8\nfunction findByNodeName(el, nodeName) {\n if (!el.prop) { // not a jQuery or jqLite object -> wrap it\n el = angular.element(el)\n }\n\n if (el.prop('nodeName') === nodeName.toUpperCase()) {\n return el\n }\n\n const c = el.children()\n for (let i = 0; c && i < c.length; i++) {\n const node = findByNodeName(c[i], nodeName)\n if (node) {\n return node\n }\n }\n}\n\n\nfunction arrayify(obj) {\n if (obj && !angular.isArray(obj)) {\n obj = [obj]\n } else if (!obj) {\n obj = []\n }\n return obj\n}\n\n\nfunction extendFunction(...fns) {\n return function extendedFunction() {\n const args = arguments\n fns.forEach(fn => fn.apply(null, args))\n }\n}\n\nfunction extendArray(primary, secondary, property) {\n if (property) {\n primary = primary[property]\n secondary = secondary[property]\n }\n if (secondary && primary) {\n angular.forEach(secondary, function(item) {\n if (primary.indexOf(item) === -1) {\n primary.push(item)\n }\n })\n return primary\n } else if (secondary) {\n return secondary\n } else {\n return primary\n }\n}\n\nfunction startsWith(str, search) {\n if (angular.isString(str) && angular.isString(search)) {\n return str.length >= search.length && str.substring(0, search.length) === search\n } else {\n return false\n }\n}\n\nfunction contains(str, search) {\n if (angular.isString(str) && angular.isString(search)) {\n return str.length >= search.length && str.indexOf(search) !== -1\n } else {\n return false\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./other/utils.js\n **/","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = \"https://github.com/formly-js/angular-formly/blob/\" + VERSION + \"/other/ERRORS_AND_WARNINGS.md#\";\nmodule.exports = exports[\"default\"];\n\n\n/** WEBPACK FOOTER **\n ** ./other/docsBaseUrl.js\n **/","module.exports = __WEBPACK_EXTERNAL_MODULE_4__;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** external {\"root\":\"apiCheck\",\"amd\":\"api-check\",\"commonjs2\":\"api-check\",\"commonjs\":\"api-check\"}\n ** module id = 4\n ** module chunks = 0\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nexports['default'] = formlyCustomValidation;\n\n// @ngInject\nfunction formlyCustomValidation(formlyUtil) {\n return {\n restrict: 'A',\n require: 'ngModel',\n link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {\n var opts = scope.options;\n opts.validation.messages = opts.validation.messages || {};\n _angularFix2['default'].forEach(opts.validation.messages, function (message, key) {\n opts.validation.messages[key] = function () {\n return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);\n };\n });\n\n var useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers');\n _angularFix2['default'].forEach(opts.validators, _angularFix2['default'].bind(null, addValidatorToPipeline, false));\n _angularFix2['default'].forEach(opts.asyncValidators, _angularFix2['default'].bind(null, addValidatorToPipeline, true));\n\n function addValidatorToPipeline(isAsync, validator, name) {\n setupMessage(validator, name);\n validator = _angularFix2['default'].isObject(validator) ? validator.expression : validator;\n if (useNewValidatorsApi) {\n setupWithValidators(validator, name, isAsync);\n } else {\n setupWithParsers(validator, name, isAsync);\n }\n }\n\n function setupMessage(validator, name) {\n var message = validator.message;\n if (message) {\n opts.validation.messages[name] = function () {\n return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue);\n };\n }\n }\n\n function setupWithValidators(validator, name, isAsync) {\n var validatorCollection = isAsync ? '$asyncValidators' : '$validators';\n\n ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {\n return formlyUtil.formlyEval(scope, validator, modelValue, viewValue);\n };\n }\n\n function setupWithParsers(validator, name, isAsync) {\n var inFlightValidator = undefined;\n ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {\n var isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue);\n if (isAsync) {\n ctrl.$pending = ctrl.$pending || {};\n ctrl.$pending[name] = true;\n inFlightValidator = isValid;\n isValid.then(function () {\n if (inFlightValidator === isValid) {\n ctrl.$setValidity(name, true);\n }\n })['catch'](function () {\n if (inFlightValidator === isValid) {\n ctrl.$setValidity(name, false);\n }\n })['finally'](function () {\n var $pending = ctrl.$pending || {};\n if (Object.keys($pending).length === 1) {\n delete ctrl.$pending;\n } else {\n delete ctrl.$pending[name];\n }\n });\n } else {\n ctrl.$setValidity(name, isValid);\n }\n return viewValue;\n });\n }\n }\n };\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./directives/formly-custom-validation.js\n **/","import angular from 'angular-fix'\nexport default formlyCustomValidation\n\n// @ngInject\nfunction formlyCustomValidation(formlyUtil) {\n return {\n restrict: 'A',\n require: 'ngModel',\n link: function formlyCustomValidationLink(scope, el, attrs, ctrl) {\n const opts = scope.options\n opts.validation.messages = opts.validation.messages || {}\n angular.forEach(opts.validation.messages, (message, key) => {\n opts.validation.messages[key] = () => {\n return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue)\n }\n })\n\n\n const useNewValidatorsApi = ctrl.hasOwnProperty('$validators') && !attrs.hasOwnProperty('useParsers')\n angular.forEach(opts.validators, angular.bind(null, addValidatorToPipeline, false))\n angular.forEach(opts.asyncValidators, angular.bind(null, addValidatorToPipeline, true))\n\n function addValidatorToPipeline(isAsync, validator, name) {\n setupMessage(validator, name)\n validator = angular.isObject(validator) ? validator.expression : validator\n if (useNewValidatorsApi) {\n setupWithValidators(validator, name, isAsync)\n } else {\n setupWithParsers(validator, name, isAsync)\n }\n }\n\n function setupMessage(validator, name) {\n const message = validator.message\n if (message) {\n opts.validation.messages[name] = () => {\n return formlyUtil.formlyEval(scope, message, ctrl.$modelValue, ctrl.$viewValue)\n }\n }\n }\n\n function setupWithValidators(validator, name, isAsync) {\n const validatorCollection = isAsync ? '$asyncValidators' : '$validators'\n\n ctrl[validatorCollection][name] = function evalValidity(modelValue, viewValue) {\n return formlyUtil.formlyEval(scope, validator, modelValue, viewValue)\n }\n }\n\n function setupWithParsers(validator, name, isAsync) {\n let inFlightValidator\n ctrl.$parsers.unshift(function evalValidityOfParser(viewValue) {\n const isValid = formlyUtil.formlyEval(scope, validator, ctrl.$modelValue, viewValue)\n if (isAsync) {\n ctrl.$pending = ctrl.$pending || {}\n ctrl.$pending[name] = true\n inFlightValidator = isValid\n isValid.then(() => {\n if (inFlightValidator === isValid) {\n ctrl.$setValidity(name, true)\n }\n }).catch(() => {\n if (inFlightValidator === isValid) {\n ctrl.$setValidity(name, false)\n }\n }).finally(() => {\n const $pending = ctrl.$pending || {}\n if (Object.keys($pending).length === 1) {\n delete ctrl.$pending\n } else {\n delete ctrl.$pending[name]\n }\n })\n } else {\n ctrl.$setValidity(name, isValid)\n }\n return viewValue\n })\n }\n },\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./directives/formly-custom-validation.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nvar _apiCheck = require('api-check');\n\nvar _apiCheck2 = _interopRequireDefault(_apiCheck);\n\nexports['default'] = formlyField;\n\n/**\n * @ngdoc directive\n * @name formlyField\n * @restrict AE\n */\n// @ngInject\nfunction formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig, formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {\n var arrayify = formlyUtil.arrayify;\n\n return {\n restrict: 'AE',\n transclude: true,\n require: '?^formlyForm',\n scope: {\n options: '=',\n model: '=',\n originalModel: '=?',\n formId: '@', // TODO remove formId in a breaking release\n index: '=?',\n fields: '=?',\n formState: '=?',\n formOptions: '=?',\n form: '=?' },\n // TODO require form in a breaking release\n controller: FormlyFieldController,\n link: fieldLink\n };\n\n // @ngInject\n function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) {\n /* eslint max-statements:[2, 34] */\n if ($scope.options.fieldGroup) {\n setupFieldGroup();\n return;\n }\n\n var fieldType = getFieldType($scope.options);\n simplifyLife($scope.options);\n mergeFieldOptionsWithTypeDefaults($scope.options, fieldType);\n extendOptionsWithDefaults($scope.options, $scope.index);\n checkApi($scope.options);\n // set field id to link labels and fields\n\n // initalization\n setFieldIdAndName();\n setDefaultValue();\n setInitialValue();\n runExpressions();\n watchExpressions();\n addValidationMessages($scope.options);\n invokeControllers($scope, $scope.options, fieldType);\n\n // function definitions\n function runExpressions() {\n // must run on next tick to make sure that the current value is correct.\n return $timeout(function runExpressionsOnNextTick() {\n var field = $scope.options;\n var currentValue = valueGetterSetter();\n _angularFix2['default'].forEach(field.expressionProperties, function runExpression(expression, prop) {\n var setter = $parse(prop).assign;\n var promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue));\n promise.then(function setFieldValue(value) {\n setter(field, value);\n });\n });\n }, 0, false);\n }\n\n function watchExpressions() {\n if ($scope.formOptions.watchAllExpressions) {\n (function () {\n var field = $scope.options;\n var currentValue = valueGetterSetter();\n _angularFix2['default'].forEach(field.expressionProperties, function watchExpression(expression, prop) {\n var setter = $parse(prop).assign;\n $scope.$watch(function expressionPropertyWatcher() {\n return formlyUtil.formlyEval($scope, expression, currentValue, currentValue);\n }, function expressionPropertyListener(value) {\n setter(field, value);\n }, true);\n });\n })();\n }\n }\n\n function valueGetterSetter(newVal) {\n if (!$scope.model || !$scope.options.key) {\n return undefined;\n }\n if (_angularFix2['default'].isDefined(newVal)) {\n parseSet($scope.options.key, $scope.model, newVal);\n }\n return parseGet($scope.options.key, $scope.model);\n }\n\n function shouldNotUseParseKey(key) {\n return _angularFix2['default'].isNumber(key) || !formlyUtil.containsSelector(key);\n }\n\n function parseSet(key, model, newVal) {\n // If either of these are null/undefined then just return undefined\n if (!key && key !== 0 || !model) {\n return;\n }\n // If we are working with a number then $parse wont work, default back to the old way for now\n if (shouldNotUseParseKey(key)) {\n // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n model[key] = newVal;\n } else {\n var setter = $parse($scope.options.key).assign;\n if (setter) {\n setter($scope.model, newVal);\n }\n }\n }\n\n function parseGet(key, model) {\n // If either of these are null/undefined then just return undefined\n if (!key && key !== 0 || !model) {\n return undefined;\n }\n\n // If we are working with a number then $parse wont work, default back to the old way for now\n if (shouldNotUseParseKey(key)) {\n // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n return model[key];\n } else {\n return $parse(key)(model);\n }\n }\n\n function simplifyLife(options) {\n // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere\n formlyUtil.reverseDeepMerge(options, {\n originalModel: options.model,\n extras: {},\n data: {},\n templateOptions: {},\n validation: {}\n });\n // create $scope.to so template authors can reference to instead of $scope.options.templateOptions\n $scope.to = $scope.options.templateOptions;\n $scope.formOptions = $scope.formOptions || {};\n }\n\n function setFieldIdAndName() {\n if (_angularFix2['default'].isFunction(formlyConfig.extras.getFieldId)) {\n $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope);\n } else {\n var formName = $scope.form && $scope.form.$name || $scope.formId;\n $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index);\n }\n $scope.options.id = $scope.id;\n $scope.name = $scope.options.name || $scope.options.id;\n $scope.options.name = $scope.name;\n }\n\n function setDefaultValue() {\n if (_angularFix2['default'].isDefined($scope.options.defaultValue) && !_angularFix2['default'].isDefined(parseGet($scope.options.key, $scope.model))) {\n parseSet($scope.options.key, $scope.model, $scope.options.defaultValue);\n }\n }\n\n function setInitialValue() {\n $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model);\n }\n\n function mergeFieldOptionsWithTypeDefaults(options, type) {\n if (type) {\n mergeOptions(options, type.defaultOptions);\n }\n var properOrder = arrayify(options.optionsTypes).reverse(); // so the right things are overridden\n _angularFix2['default'].forEach(properOrder, function (typeName) {\n mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions);\n });\n }\n\n function mergeOptions(options, extraOptions) {\n if (extraOptions) {\n if (_angularFix2['default'].isFunction(extraOptions)) {\n extraOptions = extraOptions(options, $scope);\n }\n formlyUtil.reverseDeepMerge(options, extraOptions);\n }\n }\n\n function extendOptionsWithDefaults(options, index) {\n var key = options.key || index || 0;\n _angularFix2['default'].extend(options, {\n // attach the key in case the formly-field directive is used directly\n key: key,\n value: options.value || valueGetterSetter,\n runExpressions: runExpressions,\n resetModel: resetModel,\n updateInitialValue: updateInitialValue\n });\n }\n\n function resetModel() {\n parseSet($scope.options.key, $scope.model, $scope.options.initialValue);\n if ($scope.options.formControl) {\n if (_angularFix2['default'].isArray($scope.options.formControl)) {\n _angularFix2['default'].forEach($scope.options.formControl, function (formControl) {\n resetFormControl(formControl, true);\n });\n } else {\n resetFormControl($scope.options.formControl);\n }\n }\n if ($scope.form) {\n $scope.form.$setUntouched && $scope.form.$setUntouched();\n $scope.form.$setPristine();\n }\n }\n\n function resetFormControl(formControl, isMultiNgModel) {\n if (!isMultiNgModel) {\n formControl.$setViewValue(parseGet($scope.options.key, $scope.model));\n }\n\n formControl.$render();\n formControl.$setUntouched && formControl.$setUntouched();\n formControl.$setPristine();\n\n // To prevent breaking change requiring a digest to reset $viewModel\n if (!$scope.$root.$$phase) {\n $scope.$digest();\n }\n }\n\n function updateInitialValue() {\n $scope.options.initialValue = parseGet($scope.options.key, $scope.model);\n }\n\n function addValidationMessages(options) {\n options.validation.messages = options.validation.messages || {};\n _angularFix2['default'].forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) {\n if (!options.validation.messages[name]) {\n options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) {\n return formlyUtil.formlyEval(scope, expression, modelValue, viewValue);\n };\n }\n });\n }\n\n function invokeControllers(scope) {\n var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n var type = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];\n\n _angularFix2['default'].forEach([type.controller, options.controller], function (controller) {\n if (controller) {\n $controller(controller, { $scope: scope });\n }\n });\n }\n\n function setupFieldGroup() {\n $scope.options.options = $scope.options.options || {};\n $scope.options.options.formState = $scope.formState;\n $scope.to = $scope.options.templateOptions;\n }\n }\n\n // link function\n function fieldLink(scope, el, attrs, formlyFormCtrl) {\n if (scope.options.fieldGroup) {\n setFieldGroupTemplate();\n return;\n }\n\n // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead)\n if (!formlyFormCtrl && scope.options.model) {\n scope.$watch('options.model', function () {\n return scope.options.runExpressions();\n }, true);\n }\n\n addAttributes();\n addClasses();\n\n var type = getFieldType(scope.options);\n var args = arguments;\n var thusly = this;\n var fieldCount = 0;\n var fieldManipulators = getManipulators(scope.options, scope.formOptions);\n getFieldTemplate(scope.options).then(runManipulators(fieldManipulators.preWrapper)).then(transcludeInWrappers(scope.options, scope.formOptions)).then(runManipulators(fieldManipulators.postWrapper)).then(setElementTemplate).then(watchFormControl).then(callLinkFunctions)['catch'](function (error) {\n formlyWarn('there-was-a-problem-setting-the-template-for-this-field', 'There was a problem setting the template for this field ', scope.options, error);\n });\n\n function setFieldGroupTemplate() {\n checkFieldGroupApi(scope.options);\n el.addClass('formly-field-group');\n var extraAttributes = '';\n if (scope.options.elementAttributes) {\n extraAttributes = Object.keys(scope.options.elementAttributes).map(function (key) {\n return key + '=\"' + scope.options.elementAttributes[key] + '\"';\n }).join(' ');\n }\n var modelValue = 'model';\n scope.options.form = scope.form;\n if (scope.options.key) {\n modelValue = 'model[\\'' + scope.options.key + '\\']';\n }\n getTemplate('\\n \\n \\n ').then(transcludeInWrappers(scope.options, scope.formOptions)).then(setElementTemplate);\n }\n\n function addAttributes() {\n if (scope.options.elementAttributes) {\n el.attr(scope.options.elementAttributes);\n }\n }\n\n function addClasses() {\n if (scope.options.className) {\n el.addClass(scope.options.className);\n }\n if (scope.options.type) {\n el.addClass('formly-field-' + scope.options.type);\n }\n }\n\n function setElementTemplate(templateString) {\n el.html(asHtml(templateString));\n $compile(el.contents())(scope);\n return templateString;\n }\n\n function watchFormControl(templateString) {\n var stopWatchingShowError = _angularFix2['default'].noop;\n if (scope.options.noFormControl) {\n return;\n }\n var templateEl = _angularFix2['default'].element('
' + templateString + '
');\n var ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]');\n\n if (ngModelNodes.length) {\n _angularFix2['default'].forEach(ngModelNodes, function (ngModelNode) {\n fieldCount++;\n watchFieldNameOrExistence(ngModelNode.getAttribute('name'));\n });\n }\n\n function watchFieldNameOrExistence(name) {\n var nameExpressionRegex = /\\{\\{(.*?)}}/;\n var nameExpression = nameExpressionRegex.exec(name);\n if (nameExpression) {\n name = $interpolate(name)(scope);\n }\n watchFieldExistence(name);\n }\n\n function watchFieldExistence(name) {\n scope.$watch('form[\"' + name + '\"]', function formControlChange(formControl) {\n if (formControl) {\n if (fieldCount > 1) {\n if (!scope.options.formControl) {\n scope.options.formControl = [];\n }\n scope.options.formControl.push(formControl);\n } else {\n scope.options.formControl = formControl;\n }\n scope.fc = scope.options.formControl; // shortcut for template authors\n stopWatchingShowError();\n addShowMessagesWatcher();\n addParsers();\n addFormatters();\n }\n });\n }\n\n function addShowMessagesWatcher() {\n stopWatchingShowError = scope.$watch(function watchShowValidationChange() {\n var customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression;\n var options = scope.options;\n var formControls = arrayify(scope.fc);\n if (!formControls.some(function (fc) {\n return fc.$invalid;\n })) {\n return false;\n } else if (typeof options.validation.show === 'boolean') {\n return options.validation.show;\n } else if (customExpression) {\n return formControls.some(function (fc) {\n return formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue);\n });\n } else {\n return formControls.some(function (fc) {\n var noTouchedButDirty = _angularFix2['default'].isUndefined(fc.$touched) && fc.$dirty;\n return fc.$touched || noTouchedButDirty;\n });\n }\n }, function onShowValidationChange(show) {\n scope.options.validation.errorExistsAndShouldBeVisible = show;\n scope.showError = show; // shortcut for template authors\n });\n }\n\n function addParsers() {\n setParsersOrFormatters('parsers');\n }\n\n function addFormatters() {\n setParsersOrFormatters('formatters');\n var ctrl = scope.fc;\n var formWasPristine = scope.form.$pristine;\n if (scope.options.formatters) {\n (function () {\n var value = ctrl.$modelValue;\n ctrl.$formatters.forEach(function (formatter) {\n value = formatter(value);\n });\n\n ctrl.$setViewValue(value);\n ctrl.$render();\n ctrl.$setPristine();\n if (formWasPristine) {\n scope.form.$setPristine();\n }\n })();\n }\n }\n\n function setParsersOrFormatters(which) {\n var originalThingProp = 'originalParser';\n if (which === 'formatters') {\n originalThingProp = 'originalFormatter';\n }\n\n // init with type's parsers\n var things = getThingsFromType(type);\n\n // get optionsTypes things\n things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes));\n\n // get field's things\n things = formlyUtil.extendArray(things, scope.options[which]);\n\n // convert things into formlyExpression things\n _angularFix2['default'].forEach(things, function (thing, index) {\n things[index] = getFormlyExpressionThing(thing);\n });\n\n var ngModelCtrls = scope.fc;\n if (!_angularFix2['default'].isArray(ngModelCtrls)) {\n ngModelCtrls = [ngModelCtrls];\n }\n\n _angularFix2['default'].forEach(ngModelCtrls, function (ngModelCtrl) {\n var _ngModelCtrl;\n\n ngModelCtrl['$' + which] = (_ngModelCtrl = ngModelCtrl['$' + which]).concat.apply(_ngModelCtrl, _toConsumableArray(things));\n });\n\n function getThingsFromType(theType) {\n if (!theType) {\n return [];\n }\n if (_angularFix2['default'].isString(theType)) {\n theType = formlyConfig.getType(theType, true, scope.options);\n }\n var typeThings = [];\n\n // get things from parent\n if (theType['extends']) {\n typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType['extends']));\n }\n\n // get own type's things\n typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, []));\n\n // get things from optionsTypes\n typeThings = formlyUtil.extendArray(typeThings, getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType)));\n\n return typeThings;\n }\n\n function getThingsFromOptionsTypes() {\n var optionsTypes = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];\n\n var optionsTypesThings = [];\n _angularFix2['default'].forEach(_angularFix2['default'].copy(arrayify(optionsTypes)).reverse(), function (optionsTypeName) {\n optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName));\n });\n return optionsTypesThings;\n }\n\n function getFormlyExpressionThing(thing) {\n formlyExpressionParserOrFormatterFunction[originalThingProp] = thing;\n return formlyExpressionParserOrFormatterFunction;\n\n function formlyExpressionParserOrFormatterFunction($viewValue) {\n var $modelValue = scope.options.value();\n return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue);\n }\n }\n }\n }\n\n function callLinkFunctions() {\n if (type && type.link) {\n type.link.apply(thusly, args);\n }\n if (scope.options.link) {\n scope.options.link.apply(thusly, args);\n }\n }\n\n function runManipulators(manipulators) {\n return function runManipulatorsOnTemplate(templateToManipulate) {\n var chain = $q.when(templateToManipulate);\n _angularFix2['default'].forEach(manipulators, function (manipulator) {\n chain = chain.then(function (template) {\n return $q.when(manipulator(template, scope.options, scope)).then(function (newTemplate) {\n return _angularFix2['default'].isString(newTemplate) ? newTemplate : asHtml(newTemplate);\n });\n });\n });\n return chain;\n };\n }\n }\n\n // sort-of stateless util functions\n function asHtml(el) {\n var wrapper = _angularFix2['default'].element('');\n return wrapper.append(el).html();\n }\n\n function getFieldType(options) {\n return options.type && formlyConfig.getType(options.type);\n }\n\n function getManipulators(options, formOptions) {\n var preWrapper = [];\n var postWrapper = [];\n addManipulators(options.templateManipulators);\n addManipulators(formOptions.templateManipulators);\n addManipulators(formlyConfig.templateManipulators);\n return { preWrapper: preWrapper, postWrapper: postWrapper };\n\n function addManipulators(manipulators) {\n /* eslint-disable */ // it doesn't understand this :-(\n\n var _ref = manipulators || {};\n\n var _ref$preWrapper = _ref.preWrapper;\n var pre = _ref$preWrapper === undefined ? [] : _ref$preWrapper;\n var _ref$postWrapper = _ref.postWrapper;\n var post = _ref$postWrapper === undefined ? [] : _ref$postWrapper;\n\n preWrapper = preWrapper.concat(pre);\n postWrapper = postWrapper.concat(post);\n /* eslint-enable */\n }\n }\n\n function getFieldTemplate(options) {\n function fromOptionsOrType(key, fieldType) {\n if (_angularFix2['default'].isDefined(options[key])) {\n return options[key];\n } else if (fieldType && _angularFix2['default'].isDefined(fieldType[key])) {\n return fieldType[key];\n }\n }\n\n var type = formlyConfig.getType(options.type, true, options);\n var template = fromOptionsOrType('template', type);\n var templateUrl = fromOptionsOrType('templateUrl', type);\n if (_angularFix2['default'].isUndefined(template) && !templateUrl) {\n throw formlyUsability.getFieldError('type-type-has-no-template', 'Type \\'' + options.type + '\\' has no template. On element:', options);\n }\n\n return getTemplate(templateUrl || template, _angularFix2['default'].isUndefined(template), options);\n }\n\n function getTemplate(template, isUrl, options) {\n var templatePromise = undefined;\n if (_angularFix2['default'].isFunction(template)) {\n templatePromise = $q.when(template(options));\n } else {\n templatePromise = $q.when(template);\n }\n\n if (!isUrl) {\n return templatePromise;\n } else {\n var _ret3 = (function () {\n var httpOptions = { cache: $templateCache };\n return {\n v: templatePromise.then(function (url) {\n return $http.get(url, httpOptions);\n }).then(function (response) {\n return response.data;\n })['catch'](function handleErrorGettingATemplate(error) {\n formlyWarn('problem-loading-template-for-templateurl', 'Problem loading template for ' + template, error);\n })\n };\n })();\n\n if (typeof _ret3 === 'object') return _ret3.v;\n }\n }\n\n function transcludeInWrappers(options, formOptions) {\n var wrapper = getWrapperOption(options, formOptions);\n\n return function transcludeTemplate(template) {\n if (!wrapper.length) {\n return $q.when(template);\n }\n\n wrapper.forEach(function (aWrapper) {\n formlyUsability.checkWrapper(aWrapper, options);\n runApiCheck(aWrapper, options);\n });\n var promises = wrapper.map(function (w) {\n return getTemplate(w.template || w.templateUrl, !w.template);\n });\n return $q.all(promises).then(function (wrappersTemplates) {\n wrappersTemplates.forEach(function (wrapperTemplate, index) {\n formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index]);\n });\n wrappersTemplates.reverse(); // wrapper 0 is wrapped in wrapper 1 and so on...\n var totalWrapper = wrappersTemplates.shift();\n wrappersTemplates.forEach(function (wrapperTemplate) {\n totalWrapper = doTransclusion(totalWrapper, wrapperTemplate);\n });\n return doTransclusion(totalWrapper, template);\n });\n };\n }\n\n function doTransclusion(wrapper, template) {\n var superWrapper = _angularFix2['default'].element(''); // this allows people not have to have a single root in wrappers\n superWrapper.append(wrapper);\n var transcludeEl = superWrapper.find('formly-transclude');\n if (!transcludeEl.length) {\n // try it using our custom find function\n transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude');\n }\n transcludeEl.replaceWith(template);\n return superWrapper.html();\n }\n\n function getWrapperOption(options, formOptions) {\n /* eslint complexity:[2, 6] */\n var wrapper = options.wrapper;\n // explicit null means no wrapper\n if (wrapper === null) {\n return [];\n }\n\n // nothing specified means use the default wrapper for the type\n if (!wrapper) {\n // get all wrappers that specify they apply to this type\n wrapper = arrayify(formlyConfig.getWrapperByType(options.type));\n } else {\n wrapper = arrayify(wrapper).map(formlyConfig.getWrapper);\n }\n\n // get all wrappers for that the type specified that it uses.\n var type = formlyConfig.getType(options.type, true, options);\n if (type && type.wrapper) {\n var typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper);\n wrapper = wrapper.concat(typeWrappers);\n }\n\n // add form wrappers\n if (formOptions.wrapper) {\n var formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper);\n wrapper = wrapper.concat(formWrappers);\n }\n\n // add the default wrapper last\n var defaultWrapper = formlyConfig.getWrapper();\n if (defaultWrapper) {\n wrapper.push(defaultWrapper);\n }\n return wrapper;\n }\n\n function checkApi(options) {\n formlyApiCheck['throw'](formlyApiCheck.formlyFieldOptions, options, {\n prefix: 'formly-field directive',\n url: 'formly-field-directive-validation-failed'\n });\n // validate with the type\n var type = options.type && formlyConfig.getType(options.type);\n if (type) {\n runApiCheck(type, options, true);\n }\n if (options.expressionProperties && options.expressionProperties.hide) {\n formlyWarn('dont-use-expressionproperties.hide-use-hideexpression-instead', 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead', options);\n }\n }\n\n function checkFieldGroupApi(options) {\n formlyApiCheck['throw'](formlyApiCheck.fieldGroup, options, {\n prefix: 'formly-field directive',\n url: 'formly-field-directive-validation-failed'\n });\n }\n\n function runApiCheck(_ref2, options, forType) {\n var apiCheck = _ref2.apiCheck;\n var apiCheckInstance = _ref2.apiCheckInstance;\n var apiCheckFunction = _ref2.apiCheckFunction;\n var apiCheckOptions = _ref2.apiCheckOptions;\n\n runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options);\n if (forType && options.type) {\n _angularFix2['default'].forEach(formlyConfig.getTypeHeritage(options.type), function (type) {\n runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options);\n });\n }\n }\n\n function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) {\n /* eslint complexity:[2, 9] */\n if (!apiCheck) {\n return;\n }\n var instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck;\n if (instance.config.disabled || _apiCheck2['default'].globalConfig.disabled) {\n return;\n }\n var fn = apiCheckFunction || 'warn';\n // this is the new API\n var checkerObjects = apiCheck(instance);\n _angularFix2['default'].forEach(checkerObjects, function (shape, name) {\n var checker = instance.shape(shape);\n var checkOptions = _angularFix2['default'].extend({\n prefix: 'formly-field type ' + options.type + ' for property ' + name,\n url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed'\n }, apiCheckOptions);\n instance[fn](checker, options[name], checkOptions);\n });\n }\n}\n\n// Stateless util functions\nfunction getDefaultOptionsOptionsTypes(type) {\n return getDefaultOptionsProperty(type, 'optionsTypes', []);\n}\n\nfunction getDefaultOptionsProperty(type, prop, defaultValue) {\n return type.defaultOptions && type.defaultOptions[prop] || defaultValue;\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./directives/formly-field.js\n **/","import angular from 'angular-fix'\nimport apiCheckFactory from 'api-check'\n\nexport default formlyField\n\n/**\n * @ngdoc directive\n * @name formlyField\n * @restrict AE\n */\n// @ngInject\nfunction formlyField($http, $q, $compile, $templateCache, $interpolate, formlyConfig,\n formlyApiCheck, formlyUtil, formlyUsability, formlyWarn) {\n const {arrayify} = formlyUtil\n\n return {\n restrict: 'AE',\n transclude: true,\n require: '?^formlyForm',\n scope: {\n options: '=',\n model: '=',\n originalModel: '=?',\n formId: '@', // TODO remove formId in a breaking release\n index: '=?',\n fields: '=?',\n formState: '=?',\n formOptions: '=?',\n form: '=?', // TODO require form in a breaking release\n },\n controller: FormlyFieldController,\n link: fieldLink,\n }\n\n\n // @ngInject\n function FormlyFieldController($scope, $timeout, $parse, $controller, formlyValidationMessages) {\n /* eslint max-statements:[2, 34] */\n if ($scope.options.fieldGroup) {\n setupFieldGroup()\n return\n }\n\n const fieldType = getFieldType($scope.options)\n simplifyLife($scope.options)\n mergeFieldOptionsWithTypeDefaults($scope.options, fieldType)\n extendOptionsWithDefaults($scope.options, $scope.index)\n checkApi($scope.options)\n // set field id to link labels and fields\n\n // initalization\n setFieldIdAndName()\n setDefaultValue()\n setInitialValue()\n runExpressions()\n watchExpressions()\n addValidationMessages($scope.options)\n invokeControllers($scope, $scope.options, fieldType)\n\n // function definitions\n function runExpressions() {\n // must run on next tick to make sure that the current value is correct.\n return $timeout(function runExpressionsOnNextTick() {\n const field = $scope.options\n const currentValue = valueGetterSetter()\n angular.forEach(field.expressionProperties, function runExpression(expression, prop) {\n const setter = $parse(prop).assign\n const promise = $q.when(formlyUtil.formlyEval($scope, expression, currentValue, currentValue))\n promise.then(function setFieldValue(value) {\n setter(field, value)\n })\n })\n }, 0, false)\n }\n\n function watchExpressions() {\n if ($scope.formOptions.watchAllExpressions) {\n const field = $scope.options\n const currentValue = valueGetterSetter()\n angular.forEach(field.expressionProperties, function watchExpression(expression, prop) {\n const setter = $parse(prop).assign\n $scope.$watch(function expressionPropertyWatcher() {\n return formlyUtil.formlyEval($scope, expression, currentValue, currentValue)\n }, function expressionPropertyListener(value) {\n setter(field, value)\n }, true)\n })\n }\n }\n\n function valueGetterSetter(newVal) {\n if (!$scope.model || !$scope.options.key) {\n return undefined\n }\n if (angular.isDefined(newVal)) {\n parseSet($scope.options.key, $scope.model, newVal)\n }\n return parseGet($scope.options.key, $scope.model)\n }\n\n function shouldNotUseParseKey(key) {\n return angular.isNumber(key) || !formlyUtil.containsSelector(key)\n }\n\n function parseSet(key, model, newVal) {\n // If either of these are null/undefined then just return undefined\n if ((!key && key !== 0) || !model) {\n return\n }\n // If we are working with a number then $parse wont work, default back to the old way for now\n if (shouldNotUseParseKey(key)) {\n // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n model[key] = newVal\n } else {\n const setter = $parse($scope.options.key).assign\n if (setter) {\n setter($scope.model, newVal)\n }\n }\n }\n\n function parseGet(key, model) {\n // If either of these are null/undefined then just return undefined\n if ((!key && key !== 0) || !model) {\n return undefined\n }\n\n // If we are working with a number then $parse wont work, default back to the old way for now\n if (shouldNotUseParseKey(key)) {\n // TODO: Fix this so we can get several levels instead of just one with properties that are numeric\n return model[key]\n } else {\n return $parse(key)(model)\n }\n }\n\n function simplifyLife(options) {\n // add a few empty objects (if they don't already exist) so you don't have to undefined check everywhere\n formlyUtil.reverseDeepMerge(options, {\n originalModel: options.model,\n extras: {},\n data: {},\n templateOptions: {},\n validation: {},\n })\n // create $scope.to so template authors can reference to instead of $scope.options.templateOptions\n $scope.to = $scope.options.templateOptions\n $scope.formOptions = $scope.formOptions || {}\n }\n\n function setFieldIdAndName() {\n if (angular.isFunction(formlyConfig.extras.getFieldId)) {\n $scope.id = formlyConfig.extras.getFieldId($scope.options, $scope.model, $scope)\n } else {\n const formName = ($scope.form && $scope.form.$name) || $scope.formId\n $scope.id = formlyUtil.getFieldId(formName, $scope.options, $scope.index)\n }\n $scope.options.id = $scope.id\n $scope.name = $scope.options.name || $scope.options.id\n $scope.options.name = $scope.name\n }\n\n function setDefaultValue() {\n if (angular.isDefined($scope.options.defaultValue) &&\n !angular.isDefined(parseGet($scope.options.key, $scope.model))) {\n parseSet($scope.options.key, $scope.model, $scope.options.defaultValue)\n }\n }\n\n function setInitialValue() {\n $scope.options.initialValue = $scope.model && parseGet($scope.options.key, $scope.model)\n }\n\n function mergeFieldOptionsWithTypeDefaults(options, type) {\n if (type) {\n mergeOptions(options, type.defaultOptions)\n }\n const properOrder = arrayify(options.optionsTypes).reverse() // so the right things are overridden\n angular.forEach(properOrder, typeName => {\n mergeOptions(options, formlyConfig.getType(typeName, true, options).defaultOptions)\n })\n }\n\n function mergeOptions(options, extraOptions) {\n if (extraOptions) {\n if (angular.isFunction(extraOptions)) {\n extraOptions = extraOptions(options, $scope)\n }\n formlyUtil.reverseDeepMerge(options, extraOptions)\n }\n }\n\n function extendOptionsWithDefaults(options, index) {\n const key = options.key || index || 0\n angular.extend(options, {\n // attach the key in case the formly-field directive is used directly\n key,\n value: options.value || valueGetterSetter,\n runExpressions,\n resetModel,\n updateInitialValue,\n })\n }\n\n function resetModel() {\n parseSet($scope.options.key, $scope.model, $scope.options.initialValue)\n if ($scope.options.formControl) {\n if (angular.isArray($scope.options.formControl)) {\n angular.forEach($scope.options.formControl, function(formControl) {\n resetFormControl(formControl, true)\n })\n } else {\n resetFormControl($scope.options.formControl)\n }\n }\n if ($scope.form) {\n $scope.form.$setUntouched && $scope.form.$setUntouched()\n $scope.form.$setPristine()\n }\n }\n\n function resetFormControl(formControl, isMultiNgModel) {\n if (!isMultiNgModel) {\n formControl.$setViewValue(parseGet($scope.options.key, $scope.model))\n }\n\n formControl.$render()\n formControl.$setUntouched && formControl.$setUntouched()\n formControl.$setPristine()\n\n // To prevent breaking change requiring a digest to reset $viewModel\n if (!$scope.$root.$$phase) {\n $scope.$digest()\n }\n }\n\n function updateInitialValue() {\n $scope.options.initialValue = parseGet($scope.options.key, $scope.model)\n }\n\n function addValidationMessages(options) {\n options.validation.messages = options.validation.messages || {}\n angular.forEach(formlyValidationMessages.messages, function createFunctionForMessage(expression, name) {\n if (!options.validation.messages[name]) {\n options.validation.messages[name] = function evaluateMessage(viewValue, modelValue, scope) {\n return formlyUtil.formlyEval(scope, expression, modelValue, viewValue)\n }\n }\n })\n }\n\n function invokeControllers(scope, options = {}, type = {}) {\n angular.forEach([type.controller, options.controller], controller => {\n if (controller) {\n $controller(controller, {$scope: scope})\n }\n })\n }\n\n function setupFieldGroup() {\n $scope.options.options = $scope.options.options || {}\n $scope.options.options.formState = $scope.formState\n $scope.to = $scope.options.templateOptions\n }\n }\n\n\n // link function\n function fieldLink(scope, el, attrs, formlyFormCtrl) {\n if (scope.options.fieldGroup) {\n setFieldGroupTemplate()\n return\n }\n\n // watch the field model (if exists) if there is no parent formly-form directive (that would watch it instead)\n if (!formlyFormCtrl && scope.options.model) {\n scope.$watch('options.model', () => scope.options.runExpressions(), true)\n }\n\n addAttributes()\n addClasses()\n\n const type = getFieldType(scope.options)\n const args = arguments\n const thusly = this\n let fieldCount = 0\n const fieldManipulators = getManipulators(scope.options, scope.formOptions)\n getFieldTemplate(scope.options)\n .then(runManipulators(fieldManipulators.preWrapper))\n .then(transcludeInWrappers(scope.options, scope.formOptions))\n .then(runManipulators(fieldManipulators.postWrapper))\n .then(setElementTemplate)\n .then(watchFormControl)\n .then(callLinkFunctions)\n .catch(error => {\n formlyWarn(\n 'there-was-a-problem-setting-the-template-for-this-field',\n 'There was a problem setting the template for this field ',\n scope.options,\n error\n )\n })\n\n function setFieldGroupTemplate() {\n checkFieldGroupApi(scope.options)\n el.addClass('formly-field-group')\n let extraAttributes = ''\n if (scope.options.elementAttributes) {\n extraAttributes = Object.keys(scope.options.elementAttributes).map(key => {\n return `${key}=\"${scope.options.elementAttributes[key]}\"`\n }).join(' ')\n }\n let modelValue = 'model'\n scope.options.form = scope.form\n if (scope.options.key) {\n modelValue = `model['${scope.options.key}']`\n }\n getTemplate(`\n \n \n `)\n .then(transcludeInWrappers(scope.options, scope.formOptions))\n .then(setElementTemplate)\n }\n\n function addAttributes() {\n if (scope.options.elementAttributes) {\n el.attr(scope.options.elementAttributes)\n }\n }\n\n function addClasses() {\n if (scope.options.className) {\n el.addClass(scope.options.className)\n }\n if (scope.options.type) {\n el.addClass(`formly-field-${scope.options.type}`)\n }\n }\n\n function setElementTemplate(templateString) {\n el.html(asHtml(templateString))\n $compile(el.contents())(scope)\n return templateString\n }\n\n function watchFormControl(templateString) {\n let stopWatchingShowError = angular.noop\n if (scope.options.noFormControl) {\n return\n }\n const templateEl = angular.element(`
${templateString}
`)\n const ngModelNodes = templateEl[0].querySelectorAll('[ng-model],[data-ng-model]')\n\n\n if (ngModelNodes.length) {\n angular.forEach(ngModelNodes, function(ngModelNode) {\n fieldCount++\n watchFieldNameOrExistence(ngModelNode.getAttribute('name'))\n })\n }\n\n function watchFieldNameOrExistence(name) {\n const nameExpressionRegex = /\\{\\{(.*?)}}/\n const nameExpression = nameExpressionRegex.exec(name)\n if (nameExpression) {\n name = $interpolate(name)(scope)\n }\n watchFieldExistence(name)\n }\n\n function watchFieldExistence(name) {\n scope.$watch(`form[\"${name}\"]`, function formControlChange(formControl) {\n if (formControl) {\n if (fieldCount > 1) {\n if (!scope.options.formControl) {\n scope.options.formControl = []\n }\n scope.options.formControl.push(formControl)\n } else {\n scope.options.formControl = formControl\n }\n scope.fc = scope.options.formControl // shortcut for template authors\n stopWatchingShowError()\n addShowMessagesWatcher()\n addParsers()\n addFormatters()\n }\n })\n }\n\n function addShowMessagesWatcher() {\n stopWatchingShowError = scope.$watch(function watchShowValidationChange() {\n const customExpression = formlyConfig.extras.errorExistsAndShouldBeVisibleExpression\n const options = scope.options\n const formControls = arrayify(scope.fc)\n if (!formControls.some(fc => fc.$invalid)) {\n return false\n } else if (typeof options.validation.show === 'boolean') {\n return options.validation.show\n } else if (customExpression) {\n return formControls.some(fc =>\n formlyUtil.formlyEval(scope, customExpression, fc.$modelValue, fc.$viewValue))\n } else {\n return formControls.some(fc => {\n const noTouchedButDirty = (angular.isUndefined(fc.$touched) && fc.$dirty)\n return (fc.$touched || noTouchedButDirty)\n })\n }\n }, function onShowValidationChange(show) {\n scope.options.validation.errorExistsAndShouldBeVisible = show\n scope.showError = show // shortcut for template authors\n })\n }\n\n function addParsers() {\n setParsersOrFormatters('parsers')\n }\n\n function addFormatters() {\n setParsersOrFormatters('formatters')\n const ctrl = scope.fc\n const formWasPristine = scope.form.$pristine\n if (scope.options.formatters) {\n let value = ctrl.$modelValue\n ctrl.$formatters.forEach((formatter) => {\n value = formatter(value)\n })\n\n ctrl.$setViewValue(value)\n ctrl.$render()\n ctrl.$setPristine()\n if (formWasPristine) {\n scope.form.$setPristine()\n }\n }\n }\n\n function setParsersOrFormatters(which) {\n let originalThingProp = 'originalParser'\n if (which === 'formatters') {\n originalThingProp = 'originalFormatter'\n }\n\n // init with type's parsers\n let things = getThingsFromType(type)\n\n // get optionsTypes things\n things = formlyUtil.extendArray(things, getThingsFromOptionsTypes(scope.options.optionsTypes))\n\n // get field's things\n things = formlyUtil.extendArray(things, scope.options[which])\n\n // convert things into formlyExpression things\n angular.forEach(things, (thing, index) => {\n things[index] = getFormlyExpressionThing(thing)\n })\n\n let ngModelCtrls = scope.fc\n if (!angular.isArray(ngModelCtrls)) {\n ngModelCtrls = [ngModelCtrls]\n }\n\n angular.forEach(ngModelCtrls, ngModelCtrl => {\n ngModelCtrl['$' + which] = ngModelCtrl['$' + which].concat(...things)\n })\n\n function getThingsFromType(theType) {\n if (!theType) {\n return []\n }\n if (angular.isString(theType)) {\n theType = formlyConfig.getType(theType, true, scope.options)\n }\n let typeThings = []\n\n // get things from parent\n if (theType.extends) {\n typeThings = formlyUtil.extendArray(typeThings, getThingsFromType(theType.extends))\n }\n\n // get own type's things\n typeThings = formlyUtil.extendArray(typeThings, getDefaultOptionsProperty(theType, which, []))\n\n // get things from optionsTypes\n typeThings = formlyUtil.extendArray(\n typeThings,\n getThingsFromOptionsTypes(getDefaultOptionsOptionsTypes(theType))\n )\n\n return typeThings\n }\n\n function getThingsFromOptionsTypes(optionsTypes = []) {\n let optionsTypesThings = []\n angular.forEach(angular.copy(arrayify(optionsTypes)).reverse(), optionsTypeName => {\n optionsTypesThings = formlyUtil.extendArray(optionsTypesThings, getThingsFromType(optionsTypeName))\n })\n return optionsTypesThings\n }\n\n function getFormlyExpressionThing(thing) {\n formlyExpressionParserOrFormatterFunction[originalThingProp] = thing\n return formlyExpressionParserOrFormatterFunction\n\n function formlyExpressionParserOrFormatterFunction($viewValue) {\n const $modelValue = scope.options.value()\n return formlyUtil.formlyEval(scope, thing, $modelValue, $viewValue)\n }\n }\n\n }\n }\n\n function callLinkFunctions() {\n if (type && type.link) {\n type.link.apply(thusly, args)\n }\n if (scope.options.link) {\n scope.options.link.apply(thusly, args)\n }\n }\n\n\n function runManipulators(manipulators) {\n return function runManipulatorsOnTemplate(templateToManipulate) {\n let chain = $q.when(templateToManipulate)\n angular.forEach(manipulators, manipulator => {\n chain = chain.then(template => {\n return $q.when(manipulator(template, scope.options, scope)).then(newTemplate => {\n return angular.isString(newTemplate) ? newTemplate : asHtml(newTemplate)\n })\n })\n })\n return chain\n }\n }\n }\n\n // sort-of stateless util functions\n function asHtml(el) {\n const wrapper = angular.element('')\n return wrapper.append(el).html()\n }\n\n function getFieldType(options) {\n return options.type && formlyConfig.getType(options.type)\n }\n\n function getManipulators(options, formOptions) {\n let preWrapper = []\n let postWrapper = []\n addManipulators(options.templateManipulators)\n addManipulators(formOptions.templateManipulators)\n addManipulators(formlyConfig.templateManipulators)\n return {preWrapper, postWrapper}\n\n function addManipulators(manipulators) {\n /* eslint-disable */ // it doesn't understand this :-(\n const {preWrapper:pre = [], postWrapper:post = []} = (manipulators || {});\n preWrapper = preWrapper.concat(pre);\n postWrapper = postWrapper.concat(post);\n /* eslint-enable */\n }\n }\n\n function getFieldTemplate(options) {\n function fromOptionsOrType(key, fieldType) {\n if (angular.isDefined(options[key])) {\n return options[key]\n } else if (fieldType && angular.isDefined(fieldType[key])) {\n return fieldType[key]\n }\n }\n\n const type = formlyConfig.getType(options.type, true, options)\n const template = fromOptionsOrType('template', type)\n const templateUrl = fromOptionsOrType('templateUrl', type)\n if (angular.isUndefined(template) && !templateUrl) {\n throw formlyUsability.getFieldError(\n 'type-type-has-no-template',\n `Type '${options.type}' has no template. On element:`, options\n )\n }\n\n return getTemplate(templateUrl || template, angular.isUndefined(template), options)\n }\n\n\n function getTemplate(template, isUrl, options) {\n let templatePromise\n if (angular.isFunction(template)) {\n templatePromise = $q.when(template(options))\n } else {\n templatePromise = $q.when(template)\n }\n\n if (!isUrl) {\n return templatePromise\n } else {\n const httpOptions = {cache: $templateCache}\n return templatePromise\n .then((url) => $http.get(url, httpOptions))\n .then((response) => response.data)\n .catch(function handleErrorGettingATemplate(error) {\n formlyWarn(\n 'problem-loading-template-for-templateurl',\n 'Problem loading template for ' + template,\n error\n )\n })\n }\n }\n\n function transcludeInWrappers(options, formOptions) {\n const wrapper = getWrapperOption(options, formOptions)\n\n return function transcludeTemplate(template) {\n if (!wrapper.length) {\n return $q.when(template)\n }\n\n wrapper.forEach((aWrapper) => {\n formlyUsability.checkWrapper(aWrapper, options)\n runApiCheck(aWrapper, options)\n })\n const promises = wrapper.map(w => getTemplate(w.template || w.templateUrl, !w.template))\n return $q.all(promises).then(wrappersTemplates => {\n wrappersTemplates.forEach((wrapperTemplate, index) => {\n formlyUsability.checkWrapperTemplate(wrapperTemplate, wrapper[index])\n })\n wrappersTemplates.reverse() // wrapper 0 is wrapped in wrapper 1 and so on...\n let totalWrapper = wrappersTemplates.shift()\n wrappersTemplates.forEach(wrapperTemplate => {\n totalWrapper = doTransclusion(totalWrapper, wrapperTemplate)\n })\n return doTransclusion(totalWrapper, template)\n })\n }\n }\n\n function doTransclusion(wrapper, template) {\n const superWrapper = angular.element('') // this allows people not have to have a single root in wrappers\n superWrapper.append(wrapper)\n let transcludeEl = superWrapper.find('formly-transclude')\n if (!transcludeEl.length) {\n // try it using our custom find function\n transcludeEl = formlyUtil.findByNodeName(superWrapper, 'formly-transclude')\n }\n transcludeEl.replaceWith(template)\n return superWrapper.html()\n }\n\n function getWrapperOption(options, formOptions) {\n /* eslint complexity:[2, 6] */\n let wrapper = options.wrapper\n // explicit null means no wrapper\n if (wrapper === null) {\n return []\n }\n\n // nothing specified means use the default wrapper for the type\n if (!wrapper) {\n // get all wrappers that specify they apply to this type\n wrapper = arrayify(formlyConfig.getWrapperByType(options.type))\n } else {\n wrapper = arrayify(wrapper).map(formlyConfig.getWrapper)\n }\n\n // get all wrappers for that the type specified that it uses.\n const type = formlyConfig.getType(options.type, true, options)\n if (type && type.wrapper) {\n const typeWrappers = arrayify(type.wrapper).map(formlyConfig.getWrapper)\n wrapper = wrapper.concat(typeWrappers)\n }\n\n // add form wrappers\n if (formOptions.wrapper) {\n const formWrappers = arrayify(formOptions.wrapper).map(formlyConfig.getWrapper)\n wrapper = wrapper.concat(formWrappers)\n }\n\n // add the default wrapper last\n const defaultWrapper = formlyConfig.getWrapper()\n if (defaultWrapper) {\n wrapper.push(defaultWrapper)\n }\n return wrapper\n }\n\n function checkApi(options) {\n formlyApiCheck.throw(formlyApiCheck.formlyFieldOptions, options, {\n prefix: 'formly-field directive',\n url: 'formly-field-directive-validation-failed',\n })\n // validate with the type\n const type = options.type && formlyConfig.getType(options.type)\n if (type) {\n runApiCheck(type, options, true)\n }\n if (options.expressionProperties && options.expressionProperties.hide) {\n formlyWarn(\n 'dont-use-expressionproperties.hide-use-hideexpression-instead',\n 'You have specified `hide` in `expressionProperties`. Use `hideExpression` instead',\n options\n )\n }\n }\n\n function checkFieldGroupApi(options) {\n formlyApiCheck.throw(formlyApiCheck.fieldGroup, options, {\n prefix: 'formly-field directive',\n url: 'formly-field-directive-validation-failed',\n })\n }\n\n function runApiCheck({apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions}, options, forType) {\n runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options)\n if (forType && options.type) {\n angular.forEach(formlyConfig.getTypeHeritage(options.type), function(type) {\n runApiCheckForType(type.apiCheck, type.apiCheckInstance, type.apiCheckFunction, type.apiCheckOptions, options)\n })\n }\n }\n\n function runApiCheckForType(apiCheck, apiCheckInstance, apiCheckFunction, apiCheckOptions, options) {\n /* eslint complexity:[2, 9] */\n if (!apiCheck) {\n return\n }\n const instance = apiCheckInstance || formlyConfig.extras.apiCheckInstance || formlyApiCheck\n if (instance.config.disabled || apiCheckFactory.globalConfig.disabled) {\n return\n }\n const fn = apiCheckFunction || 'warn'\n // this is the new API\n const checkerObjects = apiCheck(instance)\n angular.forEach(checkerObjects, (shape, name) => {\n const checker = instance.shape(shape)\n const checkOptions = angular.extend({\n prefix: `formly-field type ${options.type} for property ${name}`,\n url: formlyApiCheck.config.output.docsBaseUrl + 'formly-field-type-apicheck-failed',\n }, apiCheckOptions)\n instance[fn](checker, options[name], checkOptions)\n })\n }\n\n\n}\n\n\n// Stateless util functions\nfunction getDefaultOptionsOptionsTypes(type) {\n return getDefaultOptionsProperty(type, 'optionsTypes', [])\n}\n\nfunction getDefaultOptionsProperty(type, prop, defaultValue) {\n return type.defaultOptions && type.defaultOptions[prop] || defaultValue\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./directives/formly-field.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\nexports['default'] = formlyFocus;\n\n// @ngInject\nfunction formlyFocus($timeout, $document) {\n return {\n restrict: 'A',\n link: function formlyFocusLink(scope, element, attrs) {\n var previousEl = null;\n var el = element[0];\n var doc = $document[0];\n attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) {\n /* eslint no-bitwise:0 */ // I know what I'm doing. I promise...\n if (value === 'true') {\n $timeout(function setElementFocus() {\n previousEl = doc.activeElement;\n el.focus();\n }, ~ ~attrs.focusWait);\n } else if (value === 'false') {\n if (doc.activeElement === el) {\n el.blur();\n if (attrs.hasOwnProperty('refocus') && previousEl) {\n previousEl.focus();\n }\n }\n }\n });\n }\n };\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./directives/formly-focus.js\n **/","export default formlyFocus\n\n// @ngInject\nfunction formlyFocus($timeout, $document) {\n return {\n restrict: 'A',\n link: function formlyFocusLink(scope, element, attrs) {\n let previousEl = null\n const el = element[0]\n const doc = $document[0]\n attrs.$observe('formlyFocus', function respondToFocusExpressionChange(value) {\n /* eslint no-bitwise:0 */ // I know what I'm doing. I promise...\n if (value === 'true') {\n $timeout(function setElementFocus() {\n previousEl = doc.activeElement\n el.focus()\n }, ~~attrs.focusWait)\n } else if (value === 'false') {\n if (doc.activeElement === el) {\n el.blur()\n if (attrs.hasOwnProperty('refocus') && previousEl) {\n previousEl.focus()\n }\n }\n }\n })\n },\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./directives/formly-focus.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\nvar _slice = Array.prototype.slice;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nexports['default'] = formlyForm;\n\n/**\n * @ngdoc directive\n * @name formlyForm\n * @restrict AE\n */\n// @ngInject\nfunction formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) {\n var currentFormId = 1;\n return {\n restrict: 'AE',\n template: formlyFormGetTemplate,\n replace: true,\n transclude: true,\n scope: {\n fields: '=',\n model: '=',\n form: '=?',\n options: '=?'\n },\n controller: FormlyFormController,\n link: formlyFormLink\n };\n\n function formlyFormGetTemplate(el, attrs) {\n var rootEl = getRootEl();\n var fieldRootEl = getFieldRootEl();\n var formId = 'formly_' + currentFormId++;\n var parentFormAttributes = '';\n if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) {\n parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes);\n }\n return '\\n <' + rootEl + ' class=\"formly\"\\n name=\"' + getFormName() + '\"\\n role=\"form\" ' + parentFormAttributes + '>\\n <' + fieldRootEl + ' formly-field\\n ng-repeat=\"field in fields ' + getTrackBy() + '\"\\n ' + getHideDirective() + '=\"!field.hide\"\\n class=\"formly-field\"\\n options=\"field\"\\n model=\"field.model || model\"\\n original-model=\"model\"\\n fields=\"fields\"\\n form=\"theFormlyForm\"\\n form-id=\"' + getFormName() + '\"\\n form-state=\"options.formState\"\\n form-options=\"options\"\\n index=\"$index\">\\n \\n
\\n \\n ';\n\n function getRootEl() {\n return attrs.rootEl || 'ng-form';\n }\n\n function getFieldRootEl() {\n return attrs.fieldRootEl || 'div';\n }\n\n function getHideDirective() {\n return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if';\n }\n\n function getTrackBy() {\n if (!attrs.trackBy) {\n return '';\n } else {\n return 'track by ' + attrs.trackBy;\n }\n }\n\n function getFormName() {\n var formName = formId;\n var bindName = attrs.bindName;\n if (bindName) {\n if (_angularFix2['default'].version.minor < 3) {\n throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3');\n }\n // we can do a one-time binding here because we know we're in 1.3.x territory\n formName = $interpolate.startSymbol() + '::\\'formly_\\' + ' + bindName + $interpolate.endSymbol();\n }\n return formName;\n }\n\n function getTranscludeClass() {\n return attrs.transcludeClass || '';\n }\n\n function copyAttributes(attributes) {\n var excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class', 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name'];\n var arrayAttrs = [];\n _angularFix2['default'].forEach(attributes, function (_ref) {\n var nodeName = _ref.nodeName;\n var value = _ref.value;\n\n if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) {\n arrayAttrs.push(toKebabCase(nodeName) + '=\"' + value + '\"');\n }\n });\n return arrayAttrs.join(' ');\n }\n }\n\n // @ngInject\n function FormlyFormController($scope, formlyApiCheck, formlyUtil) {\n setupOptions();\n $scope.model = $scope.model || {};\n setupFields();\n\n // watch the model and evaluate watch expressions that depend on it.\n if (!$scope.options.manualModelWatcher) {\n $scope.$watch('model', onModelOrFormStateChange, true);\n } else if (_angularFix2['default'].isFunction($scope.options.manualModelWatcher)) {\n $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true);\n }\n\n if ($scope.options.formState) {\n $scope.$watch('options.formState', onModelOrFormStateChange, true);\n }\n\n function onModelOrFormStateChange() {\n _angularFix2['default'].forEach($scope.fields, runFieldExpressionProperties);\n }\n\n function validateFormControl(formControl, promise) {\n var validate = formControl.$validate;\n if (promise) {\n promise.then(validate);\n } else {\n validate();\n }\n }\n\n function runFieldExpressionProperties(field, index) {\n var model = field.model || $scope.model;\n var promise = field.runExpressions && field.runExpressions();\n if (field.hideExpression) {\n // can't use hide with expressionProperties reliably\n var val = model[field.key];\n field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });\n }\n if (field.extras && field.extras.validateOnModelChange && field.formControl) {\n if (_angularFix2['default'].isArray(field.formControl)) {\n _angularFix2['default'].forEach(field.formControl, function (formControl) {\n validateFormControl(formControl, promise);\n });\n } else {\n validateFormControl(field.formControl, promise);\n }\n }\n }\n\n function setupFields() {\n $scope.fields = $scope.fields || [];\n\n checkDeprecatedOptions($scope.options);\n\n var fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform;\n\n if (!_angularFix2['default'].isArray(fieldTransforms)) {\n fieldTransforms = [fieldTransforms];\n }\n\n _angularFix2['default'].forEach(fieldTransforms, function transformFields(fieldTransform) {\n if (fieldTransform) {\n $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form);\n if (!$scope.fields) {\n throw formlyUsability.getFormlyError('fieldTransform must return an array of fields');\n }\n }\n });\n\n setupModels();\n\n if ($scope.options.watchAllExpressions) {\n _angularFix2['default'].forEach($scope.fields, setupHideExpressionWatcher);\n }\n\n _angularFix2['default'].forEach($scope.fields, attachKey); // attaches a key based on the index if a key isn't specified\n _angularFix2['default'].forEach($scope.fields, setupWatchers); // setup watchers for all fields\n }\n\n function checkDeprecatedOptions(options) {\n if (formlyConfig.extras.fieldTransform && _angularFix2['default'].isFunction(formlyConfig.extras.fieldTransform)) {\n formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for formlyConfig.extras: ' + formlyConfig.extras.fieldTransform.name, formlyConfig.extras);\n } else if (options.fieldTransform && _angularFix2['default'].isFunction(options.fieldTransform)) {\n formlyWarn('fieldtransform-as-a-function-deprecated', 'fieldTransform as a function has been deprecated.', 'Attempted for form', options);\n }\n }\n\n function setupOptions() {\n formlyApiCheck['throw']([formlyApiCheck.formOptionsApi.optional], [$scope.options], { prefix: 'formly-form options check' });\n $scope.options = $scope.options || {};\n $scope.options.formState = $scope.options.formState || {};\n\n _angularFix2['default'].extend($scope.options, {\n updateInitialValue: updateInitialValue,\n resetModel: resetModel\n });\n }\n\n function updateInitialValue() {\n _angularFix2['default'].forEach($scope.fields, function (field) {\n if (isFieldGroup(field) && field.options) {\n field.options.updateInitialValue();\n } else {\n field.updateInitialValue();\n }\n });\n }\n\n function resetModel() {\n _angularFix2['default'].forEach($scope.fields, function (field) {\n if (isFieldGroup(field) && field.options) {\n field.options.resetModel();\n } else if (field.resetModel) {\n field.resetModel();\n }\n });\n }\n\n function setupModels() {\n // a set of field models that are already watched (the $scope.model will have its own watcher)\n var watchedModels = [$scope.model];\n // we will not set up automatic model watchers if manual mode is set\n var manualModelWatcher = $scope.options.manualModelWatcher;\n\n if ($scope.options.formState) {\n // $scope.options.formState will have its own watcher\n watchedModels.push($scope.options.formState);\n }\n\n _angularFix2['default'].forEach($scope.fields, function (field) {\n var isNewModel = initModel(field);\n\n if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) {\n $scope.$watch(function () {\n return field.model;\n }, onModelOrFormStateChange, true);\n watchedModels.push(field.model);\n }\n });\n }\n\n function setupHideExpressionWatcher(field, index) {\n if (field.hideExpression) {\n (function () {\n // can't use hide with expressionProperties reliably\n var model = field.model || $scope.model;\n $scope.$watch(function hideExpressionWatcher() {\n var val = model[field.key];\n return evalCloseToFormlyExpression(field.hideExpression, val, field, index, { model: model });\n }, function (hide) {\n return field.hide = hide;\n }, true);\n })();\n }\n }\n\n function initModel(field) {\n var isNewModel = true;\n\n if (_angularFix2['default'].isString(field.model)) {\n (function () {\n var expression = field.model;\n\n isNewModel = !referencesCurrentlyWatchedModel(expression);\n\n field.model = resolveStringModel(expression);\n\n $scope.$watch(function () {\n return resolveStringModel(expression);\n }, function (model) {\n return field.model = model;\n });\n })();\n }\n\n return isNewModel;\n\n function resolveStringModel(expression) {\n var index = $scope.fields.indexOf(field);\n var model = evalCloseToFormlyExpression(expression, undefined, field, index, { model: $scope.model });\n\n if (!model) {\n throw formlyUsability.getFieldError('field-model-must-be-initialized', 'Field model must be initialized. When specifying a model as a string for a field, the result of the' + ' expression must have been initialized ahead of time.', field);\n }\n\n return model;\n }\n }\n\n function referencesCurrentlyWatchedModel(expression) {\n return ['model', 'formState'].some(function (item) {\n return formlyUtil.startsWith(expression, item + '.') || formlyUtil.startsWith(expression, item + '[');\n });\n }\n\n function attachKey(field, index) {\n if (!isFieldGroup(field)) {\n field.key = field.key || index || 0;\n }\n }\n\n function setupWatchers(field, index) {\n if (!_angularFix2['default'].isDefined(field.watcher)) {\n return;\n }\n var watchers = field.watcher;\n if (!_angularFix2['default'].isArray(watchers)) {\n watchers = [watchers];\n }\n _angularFix2['default'].forEach(watchers, function setupWatcher(watcher) {\n if (!_angularFix2['default'].isDefined(watcher.listener) && !watcher.runFieldExpressions) {\n throw formlyUsability.getFieldError('all-field-watchers-must-have-a-listener', 'All field watchers must have a listener', field);\n }\n var watchExpression = getWatchExpression(watcher, field, index);\n var watchListener = getWatchListener(watcher, field, index);\n\n var type = watcher.type || '$watch';\n watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep);\n });\n }\n\n function getWatchExpression(watcher, field, index) {\n var watchExpression = undefined;\n if (!_angularFix2['default'].isUndefined(watcher.expression)) {\n watchExpression = watcher.expression;\n } else if (field.key) {\n watchExpression = 'model[\\'' + field.key.toString().split('.').join('\\'][\\'') + '\\']';\n }\n if (_angularFix2['default'].isFunction(watchExpression)) {\n (function () {\n // wrap the field's watch expression so we can call it with the field as the first arg\n // and the stop function as the last arg as a helper\n var originalExpression = watchExpression;\n watchExpression = function formlyWatchExpression() {\n var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));\n return originalExpression.apply(undefined, _toConsumableArray(args));\n };\n watchExpression.displayName = 'Formly Watch Expression for field for ' + field.key;\n })();\n } else if (field.model) {\n watchExpression = $parse(watchExpression).bind(null, $scope, { model: field.model });\n }\n return watchExpression;\n }\n\n function getWatchListener(watcher, field, index) {\n var watchListener = watcher.listener;\n if (_angularFix2['default'].isFunction(watchListener) || watcher.runFieldExpressions) {\n (function () {\n // wrap the field's watch listener so we can call it with the field as the first arg\n // and the stop function as the last arg as a helper\n var originalListener = watchListener;\n watchListener = function formlyWatchListener() {\n var value = undefined;\n if (originalListener) {\n var args = modifyArgs.apply(undefined, [watcher, index].concat(_slice.call(arguments)));\n value = originalListener.apply(undefined, _toConsumableArray(args));\n }\n if (watcher.runFieldExpressions) {\n runFieldExpressionProperties(field, index);\n }\n return value;\n };\n watchListener.displayName = 'Formly Watch Listener for field for ' + field.key;\n })();\n }\n return watchListener;\n }\n\n function modifyArgs(watcher, index) {\n for (var _len = arguments.length, originalArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n originalArgs[_key - 2] = arguments[_key];\n }\n\n return [$scope.fields[index]].concat(originalArgs, [watcher.stopWatching]);\n }\n\n function evalCloseToFormlyExpression(expression, val, field, index) {\n var extraLocals = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4];\n\n extraLocals = _angularFix2['default'].extend(getFormlyFieldLikeLocals(field, index), extraLocals);\n return formlyUtil.formlyEval($scope, expression, val, val, extraLocals);\n }\n\n function getFormlyFieldLikeLocals(field, index) {\n // this makes it closer to what a regular formlyExpression would be\n return {\n model: field.model,\n options: field,\n index: index,\n formState: $scope.options.formState,\n originalModel: $scope.model,\n formOptions: $scope.options,\n formId: $scope.formId\n };\n }\n }\n\n function formlyFormLink(scope, el, attrs) {\n setFormController();\n fixChromeAutocomplete();\n\n function setFormController() {\n var formId = attrs.name;\n scope.formId = formId;\n scope.theFormlyForm = scope[formId];\n if (attrs.form) {\n var getter = $parse(attrs.form);\n var setter = getter.assign;\n var parentForm = getter(scope.$parent);\n if (parentForm) {\n scope.theFormlyForm = parentForm;\n if (scope[formId]) {\n scope.theFormlyForm.$removeControl(scope[formId]);\n }\n\n // this next line is probably one of the more dangerous things that angular-formly does to improve the\n // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be\n // attached to the form that is passed to formly-form rather than the one that formly-form creates\n // this is necessary because it's confusing to have a step between the form you pass in\n // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down\n // to children forms :-( This line was added to solve this issue:\n // https://github.com/formly-js/angular-formly/issues/287\n // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0\n // so I expect it will remain this way for the life of angular 1.x\n el.removeData('$formController');\n } else {\n setter(scope.$parent, scope[formId]);\n }\n }\n if (!scope.theFormlyForm && !formlyConfig.disableWarnings) {\n /* eslint no-console:0 */\n formlyWarn('formly-form-has-no-formcontroller', 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work', el, scope);\n }\n }\n\n /*\n * chrome autocomplete lameness\n * see https://code.google.com/p/chromium/issues/detail?id=468153#c14\n * ლ(ಠ益ಠლ) (╯°□°)╯︵ ┻━┻ (◞‸◟；)\n */\n function fixChromeAutocomplete() {\n var global = formlyConfig.extras.removeChromeAutoComplete === true;\n var offInstance = scope.options && scope.options.removeChromeAutoComplete === false;\n var onInstance = scope.options && scope.options.removeChromeAutoComplete === true;\n if (global && !offInstance || onInstance) {\n var input = document.createElement('input');\n input.setAttribute('autocomplete', 'address-level4');\n input.setAttribute('hidden', 'true');\n el[0].appendChild(input);\n }\n }\n }\n\n // stateless util functions\n function toKebabCase(string) {\n if (string) {\n return string.replace(/([A-Z])/g, function ($1) {\n return '-' + $1.toLowerCase();\n });\n } else {\n return '';\n }\n }\n\n function isFieldGroup(field) {\n return field && !!field.fieldGroup;\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./directives/formly-form.js\n **/","import angular from 'angular-fix'\n\nexport default formlyForm\n\n/**\n * @ngdoc directive\n * @name formlyForm\n * @restrict AE\n */\n// @ngInject\nfunction formlyForm(formlyUsability, formlyWarn, $parse, formlyConfig, $interpolate) {\n let currentFormId = 1\n return {\n restrict: 'AE',\n template: formlyFormGetTemplate,\n replace: true,\n transclude: true,\n scope: {\n fields: '=',\n model: '=',\n form: '=?',\n options: '=?',\n },\n controller: FormlyFormController,\n link: formlyFormLink,\n }\n\n function formlyFormGetTemplate(el, attrs) {\n const rootEl = getRootEl()\n const fieldRootEl = getFieldRootEl()\n const formId = `formly_${currentFormId++}`\n let parentFormAttributes = ''\n if (attrs.hasOwnProperty('isFieldGroup') && el.parent().parent().hasClass('formly')) {\n parentFormAttributes = copyAttributes(el.parent().parent()[0].attributes)\n }\n return `\n <${rootEl} class=\"formly\"\n name=\"${getFormName()}\"\n role=\"form\" ${parentFormAttributes}>\n <${fieldRootEl} formly-field\n ng-repeat=\"field in fields ${getTrackBy()}\"\n ${getHideDirective()}=\"!field.hide\"\n class=\"formly-field\"\n options=\"field\"\n model=\"field.model || model\"\n original-model=\"model\"\n fields=\"fields\"\n form=\"theFormlyForm\"\n form-id=\"${getFormName()}\"\n form-state=\"options.formState\"\n form-options=\"options\"\n index=\"$index\">\n \n
\n \n `\n\n function getRootEl() {\n return attrs.rootEl || 'ng-form'\n }\n\n function getFieldRootEl() {\n return attrs.fieldRootEl || 'div'\n }\n\n function getHideDirective() {\n return attrs.hideDirective || formlyConfig.extras.defaultHideDirective || 'ng-if'\n }\n\n function getTrackBy() {\n if (!attrs.trackBy) {\n return ''\n } else {\n return `track by ${attrs.trackBy}`\n }\n }\n\n function getFormName() {\n let formName = formId\n const bindName = attrs.bindName\n if (bindName) {\n if (angular.version.minor < 3) {\n throw formlyUsability.getFormlyError('bind-name attribute on formly-form not allowed in < angular 1.3')\n }\n // we can do a one-time binding here because we know we're in 1.3.x territory\n formName = `${$interpolate.startSymbol()}::'formly_' + ${bindName}${$interpolate.endSymbol()}`\n }\n return formName\n }\n\n function getTranscludeClass() {\n return attrs.transcludeClass || ''\n }\n\n function copyAttributes(attributes) {\n const excluded = ['model', 'form', 'fields', 'options', 'name', 'role', 'class',\n 'data-model', 'data-form', 'data-fields', 'data-options', 'data-name']\n const arrayAttrs = []\n angular.forEach(attributes, ({nodeName, value}) => {\n if (nodeName !== 'undefined' && excluded.indexOf(nodeName) === -1) {\n arrayAttrs.push(`${toKebabCase(nodeName)}=\"${value}\"`)\n }\n })\n return arrayAttrs.join(' ')\n }\n }\n\n // @ngInject\n function FormlyFormController($scope, formlyApiCheck, formlyUtil) {\n setupOptions()\n $scope.model = $scope.model || {}\n setupFields()\n\n // watch the model and evaluate watch expressions that depend on it.\n if (!$scope.options.manualModelWatcher) {\n $scope.$watch('model', onModelOrFormStateChange, true)\n } else if (angular.isFunction($scope.options.manualModelWatcher)) {\n $scope.$watch($scope.options.manualModelWatcher, onModelOrFormStateChange, true)\n }\n\n if ($scope.options.formState) {\n $scope.$watch('options.formState', onModelOrFormStateChange, true)\n }\n\n function onModelOrFormStateChange() {\n angular.forEach($scope.fields, runFieldExpressionProperties)\n }\n\n function validateFormControl(formControl, promise) {\n const validate = formControl.$validate\n if (promise) {\n promise.then(validate)\n } else {\n validate()\n }\n }\n\n function runFieldExpressionProperties(field, index) {\n const model = field.model || $scope.model\n const promise = field.runExpressions && field.runExpressions()\n if (field.hideExpression) { // can't use hide with expressionProperties reliably\n const val = model[field.key]\n field.hide = evalCloseToFormlyExpression(field.hideExpression, val, field, index, {model})\n }\n if (field.extras && field.extras.validateOnModelChange && field.formControl) {\n if (angular.isArray(field.formControl)) {\n angular.forEach(field.formControl, function(formControl) {\n validateFormControl(formControl, promise)\n })\n } else {\n validateFormControl(field.formControl, promise)\n }\n }\n }\n\n function setupFields() {\n $scope.fields = $scope.fields || []\n\n checkDeprecatedOptions($scope.options)\n\n let fieldTransforms = $scope.options.fieldTransform || formlyConfig.extras.fieldTransform\n\n if (!angular.isArray(fieldTransforms)) {\n fieldTransforms = [fieldTransforms]\n }\n\n angular.forEach(fieldTransforms, function transformFields(fieldTransform) {\n if (fieldTransform) {\n $scope.fields = fieldTransform($scope.fields, $scope.model, $scope.options, $scope.form)\n if (!$scope.fields) {\n throw formlyUsability.getFormlyError('fieldTransform must return an array of fields')\n }\n }\n })\n\n setupModels()\n\n if ($scope.options.watchAllExpressions) {\n angular.forEach($scope.fields, setupHideExpressionWatcher)\n }\n\n angular.forEach($scope.fields, attachKey) // attaches a key based on the index if a key isn't specified\n angular.forEach($scope.fields, setupWatchers) // setup watchers for all fields\n }\n\n function checkDeprecatedOptions(options) {\n if (formlyConfig.extras.fieldTransform && angular.isFunction(formlyConfig.extras.fieldTransform)) {\n formlyWarn(\n 'fieldtransform-as-a-function-deprecated',\n 'fieldTransform as a function has been deprecated.',\n `Attempted for formlyConfig.extras: ${formlyConfig.extras.fieldTransform.name}`,\n formlyConfig.extras\n )\n } else if (options.fieldTransform && angular.isFunction(options.fieldTransform)) {\n formlyWarn(\n 'fieldtransform-as-a-function-deprecated',\n 'fieldTransform as a function has been deprecated.',\n `Attempted for form`,\n options\n )\n }\n }\n\n function setupOptions() {\n formlyApiCheck.throw(\n [formlyApiCheck.formOptionsApi.optional], [$scope.options], {prefix: 'formly-form options check'}\n )\n $scope.options = $scope.options || {}\n $scope.options.formState = $scope.options.formState || {}\n\n angular.extend($scope.options, {\n updateInitialValue,\n resetModel,\n })\n\n }\n\n function updateInitialValue() {\n angular.forEach($scope.fields, field => {\n if (isFieldGroup(field) && field.options) {\n field.options.updateInitialValue()\n } else {\n field.updateInitialValue()\n }\n })\n }\n\n function resetModel() {\n angular.forEach($scope.fields, field => {\n if (isFieldGroup(field) && field.options) {\n field.options.resetModel()\n } else if (field.resetModel) {\n field.resetModel()\n }\n })\n }\n\n function setupModels() {\n // a set of field models that are already watched (the $scope.model will have its own watcher)\n const watchedModels = [$scope.model]\n // we will not set up automatic model watchers if manual mode is set\n const manualModelWatcher = $scope.options.manualModelWatcher\n\n if ($scope.options.formState) {\n // $scope.options.formState will have its own watcher\n watchedModels.push($scope.options.formState)\n }\n\n angular.forEach($scope.fields, (field) => {\n const isNewModel = initModel(field)\n\n if (field.model && isNewModel && watchedModels.indexOf(field.model) === -1 && !manualModelWatcher) {\n $scope.$watch(() => field.model, onModelOrFormStateChange, true)\n watchedModels.push(field.model)\n }\n })\n }\n\n function setupHideExpressionWatcher(field, index) {\n if (field.hideExpression) { // can't use hide with expressionProperties reliably\n const model = field.model || $scope.model\n $scope.$watch(function hideExpressionWatcher() {\n const val = model[field.key]\n return evalCloseToFormlyExpression(field.hideExpression, val, field, index, {model})\n }, (hide) => field.hide = hide, true)\n }\n }\n\n function initModel(field) {\n let isNewModel = true\n\n if (angular.isString(field.model)) {\n const expression = field.model\n\n isNewModel = !referencesCurrentlyWatchedModel(expression)\n\n field.model = resolveStringModel(expression)\n\n $scope.$watch(() => resolveStringModel(expression), (model) => field.model = model)\n }\n\n return isNewModel\n\n function resolveStringModel(expression) {\n const index = $scope.fields.indexOf(field)\n const model = evalCloseToFormlyExpression(expression, undefined, field, index, {model: $scope.model})\n\n if (!model) {\n throw formlyUsability.getFieldError(\n 'field-model-must-be-initialized',\n 'Field model must be initialized. When specifying a model as a string for a field, the result of the' +\n ' expression must have been initialized ahead of time.',\n field)\n }\n\n return model\n }\n }\n\n function referencesCurrentlyWatchedModel(expression) {\n return ['model', 'formState'].some(item => {\n return formlyUtil.startsWith(expression, `${item}.`) || formlyUtil.startsWith(expression, `${item}[`)\n })\n }\n\n function attachKey(field, index) {\n if (!isFieldGroup(field)) {\n field.key = field.key || index || 0\n }\n }\n\n function setupWatchers(field, index) {\n if (!angular.isDefined(field.watcher)) {\n return\n }\n let watchers = field.watcher\n if (!angular.isArray(watchers)) {\n watchers = [watchers]\n }\n angular.forEach(watchers, function setupWatcher(watcher) {\n if (!angular.isDefined(watcher.listener) && !watcher.runFieldExpressions) {\n throw formlyUsability.getFieldError(\n 'all-field-watchers-must-have-a-listener',\n 'All field watchers must have a listener', field\n )\n }\n const watchExpression = getWatchExpression(watcher, field, index)\n const watchListener = getWatchListener(watcher, field, index)\n\n const type = watcher.type || '$watch'\n watcher.stopWatching = $scope[type](watchExpression, watchListener, watcher.watchDeep)\n })\n }\n\n function getWatchExpression(watcher, field, index) {\n let watchExpression\n if (!angular.isUndefined(watcher.expression)) {\n watchExpression = watcher.expression\n } else if (field.key) {\n watchExpression = 'model[\\'' + field.key.toString().split('.').join('\\'][\\'') + '\\']'\n }\n if (angular.isFunction(watchExpression)) {\n // wrap the field's watch expression so we can call it with the field as the first arg\n // and the stop function as the last arg as a helper\n const originalExpression = watchExpression\n watchExpression = function formlyWatchExpression() {\n const args = modifyArgs(watcher, index, ...arguments)\n return originalExpression(...args)\n }\n watchExpression.displayName = `Formly Watch Expression for field for ${field.key}`\n } else if (field.model) {\n watchExpression = $parse(watchExpression).bind(null, $scope, {model: field.model})\n }\n return watchExpression\n }\n\n function getWatchListener(watcher, field, index) {\n let watchListener = watcher.listener\n if (angular.isFunction(watchListener) || watcher.runFieldExpressions) {\n // wrap the field's watch listener so we can call it with the field as the first arg\n // and the stop function as the last arg as a helper\n const originalListener = watchListener\n watchListener = function formlyWatchListener() {\n let value\n if (originalListener) {\n const args = modifyArgs(watcher, index, ...arguments)\n value = originalListener(...args)\n }\n if (watcher.runFieldExpressions) {\n runFieldExpressionProperties(field, index)\n }\n return value\n }\n watchListener.displayName = `Formly Watch Listener for field for ${field.key}`\n }\n return watchListener\n }\n\n function modifyArgs(watcher, index, ...originalArgs) {\n return [$scope.fields[index], ...originalArgs, watcher.stopWatching]\n }\n\n function evalCloseToFormlyExpression(expression, val, field, index, extraLocals = {}) {\n extraLocals = angular.extend(getFormlyFieldLikeLocals(field, index), extraLocals)\n return formlyUtil.formlyEval($scope, expression, val, val, extraLocals)\n }\n\n function getFormlyFieldLikeLocals(field, index) {\n // this makes it closer to what a regular formlyExpression would be\n return {\n model: field.model,\n options: field,\n index,\n formState: $scope.options.formState,\n originalModel: $scope.model,\n formOptions: $scope.options,\n formId: $scope.formId,\n }\n }\n }\n\n function formlyFormLink(scope, el, attrs) {\n setFormController()\n fixChromeAutocomplete()\n\n function setFormController() {\n const formId = attrs.name\n scope.formId = formId\n scope.theFormlyForm = scope[formId]\n if (attrs.form) {\n const getter = $parse(attrs.form)\n const setter = getter.assign\n const parentForm = getter(scope.$parent)\n if (parentForm) {\n scope.theFormlyForm = parentForm\n if (scope[formId]) {\n scope.theFormlyForm.$removeControl(scope[formId])\n }\n\n // this next line is probably one of the more dangerous things that angular-formly does to improve the\n // API for angular-formly forms. It ensures that the NgModelControllers inside of formly-form will be\n // attached to the form that is passed to formly-form rather than the one that formly-form creates\n // this is necessary because it's confusing to have a step between the form you pass in\n // and the fields in that form. It also is because angular doesn't propagate properties like $submitted down\n // to children forms :-( This line was added to solve this issue:\n // https://github.com/formly-js/angular-formly/issues/287\n // luckily, this is how the formController has been accessed by the NgModelController since angular 1.0.0\n // so I expect it will remain this way for the life of angular 1.x\n el.removeData('$formController')\n } else {\n setter(scope.$parent, scope[formId])\n }\n }\n if (!scope.theFormlyForm && !formlyConfig.disableWarnings) {\n /* eslint no-console:0 */\n formlyWarn(\n 'formly-form-has-no-formcontroller',\n 'Your formly-form does not have a `form` property. Many functions of the form (like validation) may not work',\n el,\n scope\n )\n }\n }\n\n /*\n * chrome autocomplete lameness\n * see https://code.google.com/p/chromium/issues/detail?id=468153#c14\n * ლ(ಠ益ಠლ) (╯°□°)╯︵ ┻━┻ (◞‸◟；)\n */\n function fixChromeAutocomplete() {\n const global = formlyConfig.extras.removeChromeAutoComplete === true\n const offInstance = scope.options && scope.options.removeChromeAutoComplete === false\n const onInstance = scope.options && scope.options.removeChromeAutoComplete === true\n if ((global && !offInstance) || onInstance) {\n const input = document.createElement('input')\n input.setAttribute('autocomplete', 'address-level4')\n input.setAttribute('hidden', 'true')\n el[0].appendChild(input)\n }\n\n }\n }\n\n\n // stateless util functions\n function toKebabCase(string) {\n if (string) {\n return string.replace(/([A-Z])/g, $1 => '-' + $1.toLowerCase())\n } else {\n return ''\n }\n }\n\n function isFieldGroup(field) {\n return field && !!field.fieldGroup\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./directives/formly-form.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nvar _providersFormlyApiCheck = require('./providers/formlyApiCheck');\n\nvar _providersFormlyApiCheck2 = _interopRequireDefault(_providersFormlyApiCheck);\n\nvar _otherDocsBaseUrl = require('./other/docsBaseUrl');\n\nvar _otherDocsBaseUrl2 = _interopRequireDefault(_otherDocsBaseUrl);\n\nvar _providersFormlyUsability = require('./providers/formlyUsability');\n\nvar _providersFormlyUsability2 = _interopRequireDefault(_providersFormlyUsability);\n\nvar _providersFormlyConfig = require('./providers/formlyConfig');\n\nvar _providersFormlyConfig2 = _interopRequireDefault(_providersFormlyConfig);\n\nvar _providersFormlyValidationMessages = require('./providers/formlyValidationMessages');\n\nvar _providersFormlyValidationMessages2 = _interopRequireDefault(_providersFormlyValidationMessages);\n\nvar _servicesFormlyUtil = require('./services/formlyUtil');\n\nvar _servicesFormlyUtil2 = _interopRequireDefault(_servicesFormlyUtil);\n\nvar _servicesFormlyWarn = require('./services/formlyWarn');\n\nvar _servicesFormlyWarn2 = _interopRequireDefault(_servicesFormlyWarn);\n\nvar _directivesFormlyCustomValidation = require('./directives/formly-custom-validation');\n\nvar _directivesFormlyCustomValidation2 = _interopRequireDefault(_directivesFormlyCustomValidation);\n\nvar _directivesFormlyField = require('./directives/formly-field');\n\nvar _directivesFormlyField2 = _interopRequireDefault(_directivesFormlyField);\n\nvar _directivesFormlyFocus = require('./directives/formly-focus');\n\nvar _directivesFormlyFocus2 = _interopRequireDefault(_directivesFormlyFocus);\n\nvar _directivesFormlyForm = require('./directives/formly-form');\n\nvar _directivesFormlyForm2 = _interopRequireDefault(_directivesFormlyForm);\n\nvar _runFormlyNgModelAttrsManipulator = require('./run/formlyNgModelAttrsManipulator');\n\nvar _runFormlyNgModelAttrsManipulator2 = _interopRequireDefault(_runFormlyNgModelAttrsManipulator);\n\nvar _runFormlyCustomTags = require('./run/formlyCustomTags');\n\nvar _runFormlyCustomTags2 = _interopRequireDefault(_runFormlyCustomTags);\n\nvar ngModuleName = 'formly';\n\nexports['default'] = ngModuleName;\n\nvar ngModule = _angularFix2['default'].module(ngModuleName, []);\n\nngModule.constant('formlyApiCheck', _providersFormlyApiCheck2['default']);\nngModule.constant('formlyErrorAndWarningsUrlPrefix', _otherDocsBaseUrl2['default']);\nngModule.constant('formlyVersion', VERSION); // <-- webpack variable\n\nngModule.provider('formlyUsability', _providersFormlyUsability2['default']);\nngModule.provider('formlyConfig', _providersFormlyConfig2['default']);\n\nngModule.factory('formlyValidationMessages', _providersFormlyValidationMessages2['default']);\nngModule.factory('formlyUtil', _servicesFormlyUtil2['default']);\nngModule.factory('formlyWarn', _servicesFormlyWarn2['default']);\n\nngModule.directive('formlyCustomValidation', _directivesFormlyCustomValidation2['default']);\nngModule.directive('formlyField', _directivesFormlyField2['default']);\nngModule.directive('formlyFocus', _directivesFormlyFocus2['default']);\nngModule.directive('formlyForm', _directivesFormlyForm2['default']);\n\nngModule.run(_runFormlyNgModelAttrsManipulator2['default']);\nngModule.run(_runFormlyCustomTags2['default']);\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./index.common.js\n **/","import angular from 'angular-fix'\n\nimport formlyApiCheck from './providers/formlyApiCheck'\nimport formlyErrorAndWarningsUrlPrefix from './other/docsBaseUrl'\nimport formlyUsability from './providers/formlyUsability'\nimport formlyConfig from './providers/formlyConfig'\nimport formlyValidationMessages from './providers/formlyValidationMessages'\nimport formlyUtil from './services/formlyUtil'\nimport formlyWarn from './services/formlyWarn'\n\nimport formlyCustomValidation from './directives/formly-custom-validation'\nimport formlyField from './directives/formly-field'\nimport formlyFocus from './directives/formly-focus'\nimport formlyForm from './directives/formly-form'\n\nimport formlyNgModelAttrsManipulator from './run/formlyNgModelAttrsManipulator'\nimport formlyCustomTags from './run/formlyCustomTags'\n\nconst ngModuleName = 'formly'\n\nexport default ngModuleName\n\nconst ngModule = angular.module(ngModuleName, [])\n\nngModule.constant('formlyApiCheck', formlyApiCheck)\nngModule.constant('formlyErrorAndWarningsUrlPrefix', formlyErrorAndWarningsUrlPrefix)\nngModule.constant('formlyVersion', VERSION) // <-- webpack variable\n\nngModule.provider('formlyUsability', formlyUsability)\nngModule.provider('formlyConfig', formlyConfig)\n\nngModule.factory('formlyValidationMessages', formlyValidationMessages)\nngModule.factory('formlyUtil', formlyUtil)\nngModule.factory('formlyWarn', formlyWarn)\n\nngModule.directive('formlyCustomValidation', formlyCustomValidation)\nngModule.directive('formlyField', formlyField)\nngModule.directive('formlyFocus', formlyFocus)\nngModule.directive('formlyForm', formlyForm)\n\nngModule.run(formlyNgModelAttrsManipulator)\nngModule.run(formlyCustomTags)\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./index.common.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nvar _apiCheck = require('api-check');\n\nvar _apiCheck2 = _interopRequireDefault(_apiCheck);\n\nvar apiCheck = (0, _apiCheck2['default'])({\n output: {\n prefix: 'angular-formly:',\n docsBaseUrl: require('../other/docsBaseUrl')\n }\n});\n\nfunction shapeRequiredIfNot(otherProps, propChecker) {\n if (!_angularFix2['default'].isArray(otherProps)) {\n otherProps = [otherProps];\n }\n var type = 'specified if these are not specified: `' + otherProps.join(', ') + '` (otherwise it\\'s optional)';\n\n function shapeRequiredIfNotDefinition(prop, propName, location, obj) {\n var propExists = obj && obj.hasOwnProperty(propName);\n var otherPropsExist = otherProps.some(function (otherProp) {\n return obj && obj.hasOwnProperty(otherProp);\n });\n if (!otherPropsExist && !propExists) {\n return apiCheck.utils.getError(propName, location, type);\n } else if (propExists) {\n return propChecker(prop, propName, location, obj);\n }\n }\n\n shapeRequiredIfNotDefinition.type = type;\n return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition);\n}\n\nvar formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func]);\nvar specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable;\n\nvar apiCheckProperty = apiCheck.func;\n\nvar apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({\n warn: apiCheck.func,\n 'throw': apiCheck.func,\n shape: apiCheck.func\n}));\n\nvar apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn']));\n\nvar formlyWrapperType = apiCheck.shape({\n name: shapeRequiredIfNot('types', apiCheck.string).optional,\n template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional,\n templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional,\n types: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n overwriteOk: apiCheck.bool.optional,\n apiCheck: apiCheckProperty.optional,\n apiCheckInstance: apiCheckInstanceProperty.optional,\n apiCheckFunction: apiCheckFunctionProperty.optional,\n apiCheckOptions: apiCheck.object.optional\n}).strict;\n\nvar expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({\n expression: formlyExpression,\n message: formlyExpression.optional\n}).strict]));\n\nvar modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object]);\n\nvar templateManipulators = apiCheck.shape({\n preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,\n postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional\n}).strict.nullable;\n\nvar validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([formlyExpression, apiCheck.shape({\n expression: formlyExpression,\n message: formlyExpression.optional\n}).strict]));\n\nvar watcherChecker = apiCheck.typeOrArrayOf(apiCheck.shape({\n expression: formlyExpression.optional,\n listener: formlyExpression.optional,\n runFieldExpressions: apiCheck.bool.optional\n}));\n\nvar fieldOptionsApiShape = {\n $$hashKey: apiCheck.any.optional,\n type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional,\n template: apiCheck.shape.ifNot(['type', 'templateUrl'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n templateUrl: apiCheck.shape.ifNot(['type', 'template'], apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n model: modelChecker.optional,\n originalModel: modelChecker.optional,\n className: apiCheck.string.optional,\n id: apiCheck.string.optional,\n name: apiCheck.string.optional,\n expressionProperties: expressionProperties.optional,\n extras: apiCheck.shape({\n validateOnModelChange: apiCheck.bool.optional,\n skipNgModelAttrsManipulator: apiCheck.oneOfType([apiCheck.string, apiCheck.bool]).optional\n }).strict.optional,\n data: apiCheck.object.optional,\n templateOptions: apiCheck.object.optional,\n wrapper: specifyWrapperType.optional,\n modelOptions: apiCheck.shape({\n updateOn: apiCheck.string.optional,\n debounce: apiCheck.oneOfType([apiCheck.objectOf(apiCheck.number), apiCheck.number]).optional,\n allowInvalid: apiCheck.bool.optional,\n getterSetter: apiCheck.bool.optional,\n timezone: apiCheck.string.optional\n }).optional,\n watcher: watcherChecker.optional,\n validators: validatorChecker.optional,\n asyncValidators: validatorChecker.optional,\n parsers: apiCheck.arrayOf(formlyExpression).optional,\n formatters: apiCheck.arrayOf(formlyExpression).optional,\n noFormControl: apiCheck.bool.optional,\n hide: apiCheck.bool.optional,\n hideExpression: formlyExpression.optional,\n ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional,\n ngModelAttrs: apiCheck.objectOf(apiCheck.shape({\n statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional,\n value: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional\n }).strict).optional,\n elementAttributes: apiCheck.objectOf(apiCheck.string).optional,\n optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n link: apiCheck.func.optional,\n controller: apiCheck.oneOfType([apiCheck.string, apiCheck.func, apiCheck.array]).optional,\n validation: apiCheck.shape({\n show: apiCheck.bool.nullable.optional,\n messages: apiCheck.objectOf(formlyExpression).optional,\n errorExistsAndShouldBeVisible: apiCheck.bool.optional\n }).optional,\n formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional,\n value: apiCheck.func.optional,\n runExpressions: apiCheck.func.optional,\n templateManipulators: templateManipulators.optional,\n resetModel: apiCheck.func.optional,\n updateInitialValue: apiCheck.func.optional,\n initialValue: apiCheck.any.optional,\n defaultValue: apiCheck.any.optional\n};\n\nvar formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict;\n\nvar formOptionsApi = apiCheck.shape({\n formState: apiCheck.object.optional,\n resetModel: apiCheck.func.optional,\n updateInitialValue: apiCheck.func.optional,\n removeChromeAutoComplete: apiCheck.bool.optional,\n templateManipulators: templateManipulators.optional,\n manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional,\n watchAllExpressions: apiCheck.bool.optional,\n wrapper: specifyWrapperType.optional,\n fieldTransform: apiCheck.oneOfType([apiCheck.func, apiCheck.array]).optional,\n data: apiCheck.object.optional\n}).strict;\n\nvar fieldGroup = apiCheck.shape({\n $$hashKey: apiCheck.any.optional,\n key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n // danger. Nested field groups wont get api-checked...\n fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])),\n className: apiCheck.string.optional,\n options: formOptionsApi.optional,\n templateOptions: apiCheck.object.optional,\n wrapper: specifyWrapperType.optional,\n watcher: watcherChecker.optional,\n hide: apiCheck.bool.optional,\n hideExpression: formlyExpression.optional,\n data: apiCheck.object.optional,\n model: modelChecker.optional,\n form: apiCheck.object.optional,\n elementAttributes: apiCheck.objectOf(apiCheck.string).optional\n}).strict;\n\nvar typeOptionsDefaultOptions = _angularFix2['default'].copy(fieldOptionsApiShape);\ntypeOptionsDefaultOptions.key = apiCheck.string.optional;\n\nvar formlyTypeOptions = apiCheck.shape({\n name: apiCheck.string,\n template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n controller: apiCheck.oneOfType([apiCheck.func, apiCheck.string, apiCheck.array]).optional,\n link: apiCheck.func.optional,\n defaultOptions: apiCheck.oneOfType([apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions)]).optional,\n 'extends': apiCheck.string.optional,\n wrapper: specifyWrapperType.optional,\n data: apiCheck.object.optional,\n apiCheck: apiCheckProperty.optional,\n apiCheckInstance: apiCheckInstanceProperty.optional,\n apiCheckFunction: apiCheckFunctionProperty.optional,\n apiCheckOptions: apiCheck.object.optional,\n overwriteOk: apiCheck.bool.optional\n}).strict;\n\n_angularFix2['default'].extend(apiCheck, {\n formlyTypeOptions: formlyTypeOptions, formlyFieldOptions: formlyFieldOptions, formlyExpression: formlyExpression, formlyWrapperType: formlyWrapperType, fieldGroup: fieldGroup, formOptionsApi: formOptionsApi\n});\n\nexports['default'] = apiCheck;\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./providers/formlyApiCheck.js\n **/","import angular from 'angular-fix'\nimport apiCheckFactory from 'api-check'\n\nconst apiCheck = apiCheckFactory({\n output: {\n prefix: 'angular-formly:',\n docsBaseUrl: require('../other/docsBaseUrl'),\n },\n})\n\nfunction shapeRequiredIfNot(otherProps, propChecker) {\n if (!angular.isArray(otherProps)) {\n otherProps = [otherProps]\n }\n const type = `specified if these are not specified: \\`${otherProps.join(', ')}\\` (otherwise it's optional)`\n\n function shapeRequiredIfNotDefinition(prop, propName, location, obj) {\n const propExists = obj && obj.hasOwnProperty(propName)\n const otherPropsExist = otherProps.some(function(otherProp) {\n return obj && obj.hasOwnProperty(otherProp)\n })\n if (!otherPropsExist && !propExists) {\n return apiCheck.utils.getError(propName, location, type)\n } else if (propExists) {\n return propChecker(prop, propName, location, obj)\n }\n }\n\n shapeRequiredIfNotDefinition.type = type\n return apiCheck.utils.checkerHelpers.setupChecker(shapeRequiredIfNotDefinition)\n}\n\nconst formlyExpression = apiCheck.oneOfType([apiCheck.string, apiCheck.func])\nconst specifyWrapperType = apiCheck.typeOrArrayOf(apiCheck.string).nullable\n\nconst apiCheckProperty = apiCheck.func\n\nconst apiCheckInstanceProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.func.withProperties({\n warn: apiCheck.func,\n throw: apiCheck.func,\n shape: apiCheck.func,\n}))\n\nconst apiCheckFunctionProperty = apiCheck.shape.onlyIf('apiCheck', apiCheck.oneOf(['throw', 'warn']))\n\nconst formlyWrapperType = apiCheck.shape({\n name: shapeRequiredIfNot('types', apiCheck.string).optional,\n template: apiCheck.shape.ifNot('templateUrl', apiCheck.string).optional,\n templateUrl: apiCheck.shape.ifNot('template', apiCheck.string).optional,\n types: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n overwriteOk: apiCheck.bool.optional,\n apiCheck: apiCheckProperty.optional,\n apiCheckInstance: apiCheckInstanceProperty.optional,\n apiCheckFunction: apiCheckFunctionProperty.optional,\n apiCheckOptions: apiCheck.object.optional,\n}).strict\n\nconst expressionProperties = apiCheck.objectOf(apiCheck.oneOfType([\n formlyExpression,\n apiCheck.shape({\n expression: formlyExpression,\n message: formlyExpression.optional,\n }).strict,\n]))\n\nconst modelChecker = apiCheck.oneOfType([apiCheck.string, apiCheck.object])\n\nconst templateManipulators = apiCheck.shape({\n preWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,\n postWrapper: apiCheck.arrayOf(apiCheck.func).nullable.optional,\n}).strict.nullable\n\nconst validatorChecker = apiCheck.objectOf(apiCheck.oneOfType([\n formlyExpression, apiCheck.shape({\n expression: formlyExpression,\n message: formlyExpression.optional,\n }).strict,\n]))\n\nconst watcherChecker = apiCheck.typeOrArrayOf(\n apiCheck.shape({\n expression: formlyExpression.optional,\n listener: formlyExpression.optional,\n runFieldExpressions: apiCheck.bool.optional,\n })\n)\n\nconst fieldOptionsApiShape = {\n $$hashKey: apiCheck.any.optional,\n type: apiCheck.shape.ifNot(['template', 'templateUrl'], apiCheck.string).optional,\n template: apiCheck.shape.ifNot(\n ['type', 'templateUrl'],\n apiCheck.oneOfType([apiCheck.string, apiCheck.func])\n ).optional,\n templateUrl: apiCheck.shape.ifNot(\n ['type', 'template'],\n apiCheck.oneOfType([apiCheck.string, apiCheck.func])\n ).optional,\n key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n model: modelChecker.optional,\n originalModel: modelChecker.optional,\n className: apiCheck.string.optional,\n id: apiCheck.string.optional,\n name: apiCheck.string.optional,\n expressionProperties: expressionProperties.optional,\n extras: apiCheck.shape({\n validateOnModelChange: apiCheck.bool.optional,\n skipNgModelAttrsManipulator: apiCheck.oneOfType([\n apiCheck.string, apiCheck.bool,\n ]).optional,\n }).strict.optional,\n data: apiCheck.object.optional,\n templateOptions: apiCheck.object.optional,\n wrapper: specifyWrapperType.optional,\n modelOptions: apiCheck.shape({\n updateOn: apiCheck.string.optional,\n debounce: apiCheck.oneOfType([\n apiCheck.objectOf(apiCheck.number), apiCheck.number,\n ]).optional,\n allowInvalid: apiCheck.bool.optional,\n getterSetter: apiCheck.bool.optional,\n timezone: apiCheck.string.optional,\n }).optional,\n watcher: watcherChecker.optional,\n validators: validatorChecker.optional,\n asyncValidators: validatorChecker.optional,\n parsers: apiCheck.arrayOf(formlyExpression).optional,\n formatters: apiCheck.arrayOf(formlyExpression).optional,\n noFormControl: apiCheck.bool.optional,\n hide: apiCheck.bool.optional,\n hideExpression: formlyExpression.optional,\n ngModelElAttrs: apiCheck.objectOf(apiCheck.string).optional,\n ngModelAttrs: apiCheck.objectOf(apiCheck.shape({\n statement: apiCheck.shape.ifNot(['value', 'attribute', 'bound', 'boolean'], apiCheck.any).optional,\n value: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n attribute: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n bound: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n boolean: apiCheck.shape.ifNot('statement', apiCheck.any).optional,\n }).strict).optional,\n elementAttributes: apiCheck.objectOf(apiCheck.string).optional,\n optionsTypes: apiCheck.typeOrArrayOf(apiCheck.string).optional,\n link: apiCheck.func.optional,\n controller: apiCheck.oneOfType([\n apiCheck.string, apiCheck.func, apiCheck.array,\n ]).optional,\n validation: apiCheck.shape({\n show: apiCheck.bool.nullable.optional,\n messages: apiCheck.objectOf(formlyExpression).optional,\n errorExistsAndShouldBeVisible: apiCheck.bool.optional,\n }).optional,\n formControl: apiCheck.typeOrArrayOf(apiCheck.object).optional,\n value: apiCheck.func.optional,\n runExpressions: apiCheck.func.optional,\n templateManipulators: templateManipulators.optional,\n resetModel: apiCheck.func.optional,\n updateInitialValue: apiCheck.func.optional,\n initialValue: apiCheck.any.optional,\n defaultValue: apiCheck.any.optional,\n}\n\n\nconst formlyFieldOptions = apiCheck.shape(fieldOptionsApiShape).strict\n\nconst formOptionsApi = apiCheck.shape({\n formState: apiCheck.object.optional,\n resetModel: apiCheck.func.optional,\n updateInitialValue: apiCheck.func.optional,\n removeChromeAutoComplete: apiCheck.bool.optional,\n templateManipulators: templateManipulators.optional,\n manualModelWatcher: apiCheck.oneOfType([apiCheck.bool, apiCheck.func]).optional,\n watchAllExpressions: apiCheck.bool.optional,\n wrapper: specifyWrapperType.optional,\n fieldTransform: apiCheck.oneOfType([\n apiCheck.func, apiCheck.array,\n ]).optional,\n data: apiCheck.object.optional,\n}).strict\n\n\nconst fieldGroup = apiCheck.shape({\n $$hashKey: apiCheck.any.optional,\n key: apiCheck.oneOfType([apiCheck.string, apiCheck.number]).optional,\n // danger. Nested field groups wont get api-checked...\n fieldGroup: apiCheck.arrayOf(apiCheck.oneOfType([formlyFieldOptions, apiCheck.object])),\n className: apiCheck.string.optional,\n options: formOptionsApi.optional,\n templateOptions: apiCheck.object.optional,\n wrapper: specifyWrapperType.optional,\n watcher: watcherChecker.optional,\n hide: apiCheck.bool.optional,\n hideExpression: formlyExpression.optional,\n data: apiCheck.object.optional,\n model: modelChecker.optional,\n form: apiCheck.object.optional,\n elementAttributes: apiCheck.objectOf(apiCheck.string).optional,\n}).strict\n\nconst typeOptionsDefaultOptions = angular.copy(fieldOptionsApiShape)\ntypeOptionsDefaultOptions.key = apiCheck.string.optional\n\nconst formlyTypeOptions = apiCheck.shape({\n name: apiCheck.string,\n template: apiCheck.shape.ifNot('templateUrl', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n templateUrl: apiCheck.shape.ifNot('template', apiCheck.oneOfType([apiCheck.string, apiCheck.func])).optional,\n controller: apiCheck.oneOfType([\n apiCheck.func, apiCheck.string, apiCheck.array,\n ]).optional,\n link: apiCheck.func.optional,\n defaultOptions: apiCheck.oneOfType([\n apiCheck.func, apiCheck.shape(typeOptionsDefaultOptions),\n ]).optional,\n extends: apiCheck.string.optional,\n wrapper: specifyWrapperType.optional,\n data: apiCheck.object.optional,\n apiCheck: apiCheckProperty.optional,\n apiCheckInstance: apiCheckInstanceProperty.optional,\n apiCheckFunction: apiCheckFunctionProperty.optional,\n apiCheckOptions: apiCheck.object.optional,\n overwriteOk: apiCheck.bool.optional,\n}).strict\n\nangular.extend(apiCheck, {\n formlyTypeOptions, formlyFieldOptions, formlyExpression, formlyWrapperType, fieldGroup, formOptionsApi,\n})\n\nexport default apiCheck\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./providers/formlyApiCheck.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nvar _otherUtils = require('../other/utils');\n\nvar _otherUtils2 = _interopRequireDefault(_otherUtils);\n\nexports['default'] = formlyConfig;\n\n// @ngInject\nfunction formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) {\n var _this2 = this;\n\n var typeMap = {};\n var templateWrappersMap = {};\n var defaultWrapperName = 'default';\n var _this = this;\n var getError = formlyUsabilityProvider.getFormlyError;\n\n _angularFix2['default'].extend(this, {\n setType: setType,\n getType: getType,\n getTypes: getTypes,\n getTypeHeritage: getTypeHeritage,\n setWrapper: setWrapper,\n getWrapper: getWrapper,\n getWrapperByType: getWrapperByType,\n removeWrapperByName: removeWrapperByName,\n removeWrappersForType: removeWrappersForType,\n disableWarnings: false,\n extras: {\n disableNgModelAttrsManipulator: false,\n fieldTransform: [],\n ngModelAttrsManipulatorPreferUnbound: false,\n removeChromeAutoComplete: false,\n defaultHideDirective: 'ng-if',\n getFieldId: null\n },\n templateManipulators: {\n preWrapper: [],\n postWrapper: []\n },\n $get: function $get() {\n return _this2;\n }\n });\n\n function setType(options) {\n if (_angularFix2['default'].isArray(options)) {\n var _ret = (function () {\n var allTypes = [];\n _angularFix2['default'].forEach(options, function (item) {\n allTypes.push(setType(item));\n });\n return {\n v: allTypes\n };\n })();\n\n if (typeof _ret === 'object') return _ret.v;\n } else if (_angularFix2['default'].isObject(options)) {\n checkType(options);\n if (options['extends']) {\n extendTypeOptions(options);\n }\n typeMap[options.name] = options;\n return typeMap[options.name];\n } else {\n throw getError('You must provide an object or array for setType. You provided: ' + JSON.stringify(arguments));\n }\n }\n\n function checkType(options) {\n formlyApiCheck['throw'](formlyApiCheck.formlyTypeOptions, options, {\n prefix: 'formlyConfig.setType',\n url: 'settype-validation-failed'\n });\n if (!options.overwriteOk) {\n checkOverwrite(options.name, typeMap, options, 'types');\n } else {\n options.overwriteOk = undefined;\n }\n }\n\n function extendTypeOptions(options) {\n var extendsType = getType(options['extends'], true, options);\n extendTypeControllerFunction(options, extendsType);\n extendTypeLinkFunction(options, extendsType);\n extendTypeDefaultOptions(options, extendsType);\n _otherUtils2['default'].reverseDeepMerge(options, extendsType);\n extendTemplate(options, extendsType);\n }\n\n function extendTemplate(options, extendsType) {\n if (options.template && extendsType.templateUrl) {\n delete options.templateUrl;\n } else if (options.templateUrl && extendsType.template) {\n delete options.template;\n }\n }\n\n function extendTypeControllerFunction(options, extendsType) {\n var extendsCtrl = extendsType.controller;\n if (!_angularFix2['default'].isDefined(extendsCtrl)) {\n return;\n }\n var optionsCtrl = options.controller;\n if (_angularFix2['default'].isDefined(optionsCtrl)) {\n options.controller = function ($scope, $controller) {\n $controller(extendsCtrl, { $scope: $scope });\n $controller(optionsCtrl, { $scope: $scope });\n };\n options.controller.$inject = ['$scope', '$controller'];\n } else {\n options.controller = extendsCtrl;\n }\n }\n\n function extendTypeLinkFunction(options, extendsType) {\n var extendsFn = extendsType.link;\n if (!_angularFix2['default'].isDefined(extendsFn)) {\n return;\n }\n var optionsFn = options.link;\n if (_angularFix2['default'].isDefined(optionsFn)) {\n options.link = function () {\n extendsFn.apply(undefined, arguments);\n optionsFn.apply(undefined, arguments);\n };\n } else {\n options.link = extendsFn;\n }\n }\n\n function extendTypeDefaultOptions(options, extendsType) {\n var extendsDO = extendsType.defaultOptions;\n if (!_angularFix2['default'].isDefined(extendsDO)) {\n return;\n }\n var optionsDO = options.defaultOptions;\n var optionsDOIsFn = _angularFix2['default'].isFunction(optionsDO);\n var extendsDOIsFn = _angularFix2['default'].isFunction(extendsDO);\n if (extendsDOIsFn) {\n options.defaultOptions = function defaultOptions(opts, scope) {\n var extendsDefaultOptions = extendsDO(opts, scope);\n var mergedDefaultOptions = {};\n _otherUtils2['default'].reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions);\n var extenderOptionsDefaultOptions = optionsDO;\n if (optionsDOIsFn) {\n extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope);\n }\n _otherUtils2['default'].reverseDeepMerge(extendsDefaultOptions, extenderOptionsDefaultOptions);\n return extendsDefaultOptions;\n };\n } else if (optionsDOIsFn) {\n options.defaultOptions = function defaultOptions(opts, scope) {\n var newDefaultOptions = {};\n _otherUtils2['default'].reverseDeepMerge(newDefaultOptions, opts, extendsDO);\n return optionsDO(newDefaultOptions, scope);\n };\n }\n }\n\n function getType(name, throwError, errorContext) {\n if (!name) {\n return undefined;\n }\n var type = typeMap[name];\n if (!type && throwError === true) {\n throw getError('There is no type by the name of \"' + name + '\": ' + JSON.stringify(errorContext));\n } else {\n return type;\n }\n }\n\n function getTypes() {\n return typeMap;\n }\n\n function getTypeHeritage(parent) {\n var heritage = [];\n var type = parent;\n if (_angularFix2['default'].isString(type)) {\n type = getType(parent);\n }\n parent = type['extends'];\n while (parent) {\n type = getType(parent);\n heritage.push(type);\n parent = type['extends'];\n }\n return heritage;\n }\n\n function setWrapper(_x, _x2) {\n var _again = true;\n\n _function: while (_again) {\n var options = _x,\n name = _x2;\n _again = false;\n\n if (_angularFix2['default'].isArray(options)) {\n return options.map(function (wrapperOptions) {\n return setWrapper(wrapperOptions);\n });\n } else if (_angularFix2['default'].isObject(options)) {\n options.types = getOptionsTypes(options);\n options.name = getOptionsName(options, name);\n checkWrapperAPI(options);\n templateWrappersMap[options.name] = options;\n return options;\n } else if (_angularFix2['default'].isString(options)) {\n _x = {\n template: options,\n name: name\n };\n _x2 = undefined;\n _again = true;\n continue _function;\n }\n }\n }\n\n function getOptionsTypes(options) {\n if (_angularFix2['default'].isString(options.types)) {\n return [options.types];\n }\n if (!_angularFix2['default'].isDefined(options.types)) {\n return [];\n } else {\n return options.types;\n }\n }\n\n function getOptionsName(options, name) {\n return options.name || name || options.types.join(' ') || defaultWrapperName;\n }\n\n function checkWrapperAPI(options) {\n formlyUsabilityProvider.checkWrapper(options);\n if (options.template) {\n formlyUsabilityProvider.checkWrapperTemplate(options.template, options);\n }\n if (!options.overwriteOk) {\n checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers');\n } else {\n delete options.overwriteOk;\n }\n checkWrapperTypes(options);\n }\n\n function checkWrapperTypes(options) {\n var shouldThrow = !_angularFix2['default'].isArray(options.types) || !options.types.every(_angularFix2['default'].isString);\n if (shouldThrow) {\n throw getError('Attempted to create a template wrapper with types that is not a string or an array of strings');\n }\n }\n\n function checkOverwrite(property, object, newValue, objectName) {\n if (object.hasOwnProperty(property)) {\n warn('overwriting-types-or-wrappers', ['Attempting to overwrite ' + property + ' on ' + objectName + ' which is currently', JSON.stringify(object[property]) + ' with ' + JSON.stringify(newValue), 'To supress this warning, specify the property \"overwriteOk: true\"'].join(' '));\n }\n }\n\n function getWrapper(name) {\n return templateWrappersMap[name || defaultWrapperName];\n }\n\n function getWrapperByType(type) {\n /* eslint prefer-const:0 */\n var wrappers = [];\n for (var _name in templateWrappersMap) {\n if (templateWrappersMap.hasOwnProperty(_name)) {\n if (templateWrappersMap[_name].types && templateWrappersMap[_name].types.indexOf(type) !== -1) {\n wrappers.push(templateWrappersMap[_name]);\n }\n }\n }\n return wrappers;\n }\n\n function removeWrapperByName(name) {\n var wrapper = templateWrappersMap[name];\n delete templateWrappersMap[name];\n return wrapper;\n }\n\n function removeWrappersForType(type) {\n var wrappers = getWrapperByType(type);\n if (!wrappers) {\n return undefined;\n }\n if (!_angularFix2['default'].isArray(wrappers)) {\n return removeWrapperByName(wrappers.name);\n } else {\n wrappers.forEach(function (wrapper) {\n return removeWrapperByName(wrapper.name);\n });\n return wrappers;\n }\n }\n\n function warn() {\n if (!_this.disableWarnings && console.warn) {\n /* eslint no-console:0 */\n var args = Array.prototype.slice.call(arguments);\n var warnInfoSlug = args.shift();\n args.unshift('Formly Warning:');\n args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);\n console.warn.apply(console, _toConsumableArray(args));\n }\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./providers/formlyConfig.js\n **/","import angular from 'angular-fix'\nimport utils from '../other/utils'\n\nexport default formlyConfig\n\n// @ngInject\nfunction formlyConfig(formlyUsabilityProvider, formlyErrorAndWarningsUrlPrefix, formlyApiCheck) {\n\n const typeMap = {}\n const templateWrappersMap = {}\n const defaultWrapperName = 'default'\n const _this = this\n const getError = formlyUsabilityProvider.getFormlyError\n\n angular.extend(this, {\n setType,\n getType,\n getTypes,\n getTypeHeritage,\n setWrapper,\n getWrapper,\n getWrapperByType,\n removeWrapperByName,\n removeWrappersForType,\n disableWarnings: false,\n extras: {\n disableNgModelAttrsManipulator: false,\n fieldTransform: [],\n ngModelAttrsManipulatorPreferUnbound: false,\n removeChromeAutoComplete: false,\n defaultHideDirective: 'ng-if',\n getFieldId: null,\n },\n templateManipulators: {\n preWrapper: [],\n postWrapper: [],\n },\n $get: () => this,\n })\n\n function setType(options) {\n if (angular.isArray(options)) {\n const allTypes = []\n angular.forEach(options, item => {\n allTypes.push(setType(item))\n })\n return allTypes\n } else if (angular.isObject(options)) {\n checkType(options)\n if (options.extends) {\n extendTypeOptions(options)\n }\n typeMap[options.name] = options\n return typeMap[options.name]\n } else {\n throw getError(`You must provide an object or array for setType. You provided: ${JSON.stringify(arguments)}`)\n }\n }\n\n function checkType(options) {\n formlyApiCheck.throw(formlyApiCheck.formlyTypeOptions, options, {\n prefix: 'formlyConfig.setType',\n url: 'settype-validation-failed',\n })\n if (!options.overwriteOk) {\n checkOverwrite(options.name, typeMap, options, 'types')\n } else {\n options.overwriteOk = undefined\n }\n }\n\n function extendTypeOptions(options) {\n const extendsType = getType(options.extends, true, options)\n extendTypeControllerFunction(options, extendsType)\n extendTypeLinkFunction(options, extendsType)\n extendTypeDefaultOptions(options, extendsType)\n utils.reverseDeepMerge(options, extendsType)\n extendTemplate(options, extendsType)\n }\n\n function extendTemplate(options, extendsType) {\n if (options.template && extendsType.templateUrl) {\n delete options.templateUrl\n } else if (options.templateUrl && extendsType.template) {\n delete options.template\n }\n }\n\n function extendTypeControllerFunction(options, extendsType) {\n const extendsCtrl = extendsType.controller\n if (!angular.isDefined(extendsCtrl)) {\n return\n }\n const optionsCtrl = options.controller\n if (angular.isDefined(optionsCtrl)) {\n options.controller = function($scope, $controller) {\n $controller(extendsCtrl, {$scope})\n $controller(optionsCtrl, {$scope})\n }\n options.controller.$inject = ['$scope', '$controller']\n } else {\n options.controller = extendsCtrl\n }\n }\n\n function extendTypeLinkFunction(options, extendsType) {\n const extendsFn = extendsType.link\n if (!angular.isDefined(extendsFn)) {\n return\n }\n const optionsFn = options.link\n if (angular.isDefined(optionsFn)) {\n options.link = function() {\n extendsFn(...arguments)\n optionsFn(...arguments)\n }\n } else {\n options.link = extendsFn\n }\n }\n\n function extendTypeDefaultOptions(options, extendsType) {\n const extendsDO = extendsType.defaultOptions\n if (!angular.isDefined(extendsDO)) {\n return\n }\n const optionsDO = options.defaultOptions\n const optionsDOIsFn = angular.isFunction(optionsDO)\n const extendsDOIsFn = angular.isFunction(extendsDO)\n if (extendsDOIsFn) {\n options.defaultOptions = function defaultOptions(opts, scope) {\n const extendsDefaultOptions = extendsDO(opts, scope)\n const mergedDefaultOptions = {}\n utils.reverseDeepMerge(mergedDefaultOptions, opts, extendsDefaultOptions)\n let extenderOptionsDefaultOptions = optionsDO\n if (optionsDOIsFn) {\n extenderOptionsDefaultOptions = extenderOptionsDefaultOptions(mergedDefaultOptions, scope)\n }\n utils.reverseDeepMerge(extendsDefaultOptions, extenderOptionsDefaultOptions)\n return extendsDefaultOptions\n }\n } else if (optionsDOIsFn) {\n options.defaultOptions = function defaultOptions(opts, scope) {\n const newDefaultOptions = {}\n utils.reverseDeepMerge(newDefaultOptions, opts, extendsDO)\n return optionsDO(newDefaultOptions, scope)\n }\n }\n }\n\n function getType(name, throwError, errorContext) {\n if (!name) {\n return undefined\n }\n const type = typeMap[name]\n if (!type && throwError === true) {\n throw getError(\n `There is no type by the name of \"${name}\": ${JSON.stringify(errorContext)}`\n )\n } else {\n return type\n }\n }\n\n function getTypes() {\n return typeMap\n }\n\n function getTypeHeritage(parent) {\n const heritage = []\n let type = parent\n if (angular.isString(type)) {\n type = getType(parent)\n }\n parent = type.extends\n while (parent) {\n type = getType(parent)\n heritage.push(type)\n parent = type.extends\n }\n return heritage\n }\n\n\n function setWrapper(options, name) {\n if (angular.isArray(options)) {\n return options.map(wrapperOptions => setWrapper(wrapperOptions))\n } else if (angular.isObject(options)) {\n options.types = getOptionsTypes(options)\n options.name = getOptionsName(options, name)\n checkWrapperAPI(options)\n templateWrappersMap[options.name] = options\n return options\n } else if (angular.isString(options)) {\n return setWrapper({\n template: options,\n name,\n })\n }\n }\n\n function getOptionsTypes(options) {\n if (angular.isString(options.types)) {\n return [options.types]\n }\n if (!angular.isDefined(options.types)) {\n return []\n } else {\n return options.types\n }\n }\n\n function getOptionsName(options, name) {\n return options.name || name || options.types.join(' ') || defaultWrapperName\n }\n\n function checkWrapperAPI(options) {\n formlyUsabilityProvider.checkWrapper(options)\n if (options.template) {\n formlyUsabilityProvider.checkWrapperTemplate(options.template, options)\n }\n if (!options.overwriteOk) {\n checkOverwrite(options.name, templateWrappersMap, options, 'templateWrappers')\n } else {\n delete options.overwriteOk\n }\n checkWrapperTypes(options)\n }\n\n function checkWrapperTypes(options) {\n const shouldThrow = !angular.isArray(options.types) || !options.types.every(angular.isString)\n if (shouldThrow) {\n throw getError(`Attempted to create a template wrapper with types that is not a string or an array of strings`)\n }\n }\n\n function checkOverwrite(property, object, newValue, objectName) {\n if (object.hasOwnProperty(property)) {\n warn('overwriting-types-or-wrappers', [\n `Attempting to overwrite ${property} on ${objectName} which is currently`,\n `${JSON.stringify(object[property])} with ${JSON.stringify(newValue)}`,\n `To supress this warning, specify the property \"overwriteOk: true\"`,\n ].join(' '))\n }\n }\n\n function getWrapper(name) {\n return templateWrappersMap[name || defaultWrapperName]\n }\n\n function getWrapperByType(type) {\n /* eslint prefer-const:0 */\n const wrappers = []\n for (let name in templateWrappersMap) {\n if (templateWrappersMap.hasOwnProperty(name)) {\n if (templateWrappersMap[name].types && templateWrappersMap[name].types.indexOf(type) !== -1) {\n wrappers.push(templateWrappersMap[name])\n }\n }\n }\n return wrappers\n }\n\n function removeWrapperByName(name) {\n const wrapper = templateWrappersMap[name]\n delete templateWrappersMap[name]\n return wrapper\n }\n\n function removeWrappersForType(type) {\n const wrappers = getWrapperByType(type)\n if (!wrappers) {\n return undefined\n }\n if (!angular.isArray(wrappers)) {\n return removeWrapperByName(wrappers.name)\n } else {\n wrappers.forEach((wrapper) => removeWrapperByName(wrapper.name))\n return wrappers\n }\n }\n\n\n function warn() {\n if (!_this.disableWarnings && console.warn) {\n /* eslint no-console:0 */\n const args = Array.prototype.slice.call(arguments)\n const warnInfoSlug = args.shift()\n args.unshift('Formly Warning:')\n args.push(`${formlyErrorAndWarningsUrlPrefix}${warnInfoSlug}`)\n console.warn(...args)\n }\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./providers/formlyConfig.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nexports['default'] = formlyUsability;\n\n// @ngInject\nfunction formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {\n var _this = this;\n\n _angularFix2['default'].extend(this, {\n getFormlyError: getFormlyError,\n getFieldError: getFieldError,\n checkWrapper: checkWrapper,\n checkWrapperTemplate: checkWrapperTemplate,\n getErrorMessage: getErrorMessage,\n $get: function $get() {\n return _this;\n }\n });\n\n function getFieldError(errorInfoSlug, message, field) {\n if (arguments.length < 3) {\n field = message;\n message = errorInfoSlug;\n errorInfoSlug = null;\n }\n return new Error(getErrorMessage(errorInfoSlug, message) + (' Field definition: ' + _angularFix2['default'].toJson(field)));\n }\n\n function getFormlyError(errorInfoSlug, message) {\n if (!message) {\n message = errorInfoSlug;\n errorInfoSlug = null;\n }\n return new Error(getErrorMessage(errorInfoSlug, message));\n }\n\n function getErrorMessage(errorInfoSlug, message) {\n var url = '';\n if (errorInfoSlug !== null) {\n url = '' + formlyErrorAndWarningsUrlPrefix + errorInfoSlug;\n }\n return 'Formly Error: ' + message + '. ' + url;\n }\n\n function checkWrapper(wrapper) {\n formlyApiCheck['throw'](formlyApiCheck.formlyWrapperType, wrapper, {\n prefix: 'formlyConfig.setWrapper',\n urlSuffix: 'setwrapper-validation-failed'\n });\n }\n\n function checkWrapperTemplate(template, additionalInfo) {\n var formlyTransclude = '';\n if (template.indexOf(formlyTransclude) === -1) {\n throw getFormlyError('Template wrapper templates must use \"' + formlyTransclude + '\" somewhere in them. ' + ('This one does not have \"\" in it: ' + template) + '\\n' + ('Additional information: ' + JSON.stringify(additionalInfo)));\n }\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./providers/formlyUsability.js\n **/","import angular from 'angular-fix'\n\nexport default formlyUsability\n\n// @ngInject\nfunction formlyUsability(formlyApiCheck, formlyErrorAndWarningsUrlPrefix) {\n angular.extend(this, {\n getFormlyError,\n getFieldError,\n checkWrapper,\n checkWrapperTemplate,\n getErrorMessage,\n $get: () => this,\n })\n\n function getFieldError(errorInfoSlug, message, field) {\n if (arguments.length < 3) {\n field = message\n message = errorInfoSlug\n errorInfoSlug = null\n }\n return new Error(getErrorMessage(errorInfoSlug, message) + ` Field definition: ${angular.toJson(field)}`)\n }\n\n function getFormlyError(errorInfoSlug, message) {\n if (!message) {\n message = errorInfoSlug\n errorInfoSlug = null\n }\n return new Error(getErrorMessage(errorInfoSlug, message))\n }\n\n function getErrorMessage(errorInfoSlug, message) {\n let url = ''\n if (errorInfoSlug !== null) {\n url = `${formlyErrorAndWarningsUrlPrefix}${errorInfoSlug}`\n }\n return `Formly Error: ${message}. ${url}`\n }\n\n function checkWrapper(wrapper) {\n formlyApiCheck.throw(formlyApiCheck.formlyWrapperType, wrapper, {\n prefix: 'formlyConfig.setWrapper',\n urlSuffix: 'setwrapper-validation-failed',\n })\n }\n\n function checkWrapperTemplate(template, additionalInfo) {\n const formlyTransclude = ''\n if (template.indexOf(formlyTransclude) === -1) {\n throw getFormlyError(\n `Template wrapper templates must use \"${formlyTransclude}\" somewhere in them. ` +\n `This one does not have \"\" in it: ${template}` + '\\n' +\n `Additional information: ${JSON.stringify(additionalInfo)}`\n )\n }\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./providers/formlyUsability.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\nexports['default'] = formlyValidationMessages;\n\n// @ngInject\nfunction formlyValidationMessages() {\n\n var validationMessages = {\n addTemplateOptionValueMessage: addTemplateOptionValueMessage,\n addStringMessage: addStringMessage,\n messages: {}\n };\n\n return validationMessages;\n\n function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) {\n validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate);\n }\n\n function addStringMessage(name, string) {\n validationMessages.messages[name] = function () {\n return string;\n };\n }\n\n function templateOptionValue(prop, prefix, suffix, alternate) {\n return function getValidationMessage(viewValue, modelValue, scope) {\n if (typeof scope.options.templateOptions[prop] !== 'undefined') {\n return prefix + ' ' + scope.options.templateOptions[prop] + ' ' + suffix;\n } else {\n return alternate;\n }\n };\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./providers/formlyValidationMessages.js\n **/","export default formlyValidationMessages\n\n\n// @ngInject\nfunction formlyValidationMessages() {\n\n const validationMessages = {\n addTemplateOptionValueMessage,\n addStringMessage,\n messages: {},\n }\n\n return validationMessages\n\n function addTemplateOptionValueMessage(name, prop, prefix, suffix, alternate) {\n validationMessages.messages[name] = templateOptionValue(prop, prefix, suffix, alternate)\n }\n\n function addStringMessage(name, string) {\n validationMessages.messages[name] = () => string\n }\n\n\n function templateOptionValue(prop, prefix, suffix, alternate) {\n return function getValidationMessage(viewValue, modelValue, scope) {\n if (typeof scope.options.templateOptions[prop] !== 'undefined') {\n return `${prefix} ${scope.options.templateOptions[prop]} ${suffix}`\n } else {\n return alternate\n }\n }\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./providers/formlyValidationMessages.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nexports['default'] = addCustomTags;\n\n// @ngInject\nfunction addCustomTags($document) {\n // IE8 check ->\n // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx\n if ($document && $document.documentMode < 9) {\n (function () {\n var document = $document.get(0);\n // add the custom elements that we need for formly\n var customElements = ['formly-field', 'formly-form'];\n _angularFix2['default'].forEach(customElements, function (el) {\n document.createElement(el);\n });\n })();\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./run/formlyCustomTags.js\n **/","import angular from 'angular-fix'\nexport default addCustomTags\n\n// @ngInject\nfunction addCustomTags($document) {\n // IE8 check ->\n // https://msdn.microsoft.com/en-us/library/cc196988(v=vs.85).aspx\n if ($document && $document.documentMode < 9) {\n const document = $document.get(0)\n // add the custom elements that we need for formly\n const customElements = [\n 'formly-field', 'formly-form',\n ]\n angular.forEach(customElements, el => {\n document.createElement(el)\n })\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./run/formlyCustomTags.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _angularFix = require('angular-fix');\n\nvar _angularFix2 = _interopRequireDefault(_angularFix);\n\nvar _otherUtils = require('../other/utils');\n\nexports['default'] = addFormlyNgModelAttrsManipulator;\n\n// @ngInject\nfunction addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) {\n if (formlyConfig.extras.disableNgModelAttrsManipulator) {\n return;\n }\n formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator);\n\n function ngModelAttrsManipulator(template, options, scope) {\n var node = document.createElement('div');\n var skip = options.extras && options.extras.skipNgModelAttrsManipulator;\n if (skip === true) {\n return template;\n }\n node.innerHTML = template;\n\n var modelNodes = getNgModelNodes(node, skip);\n if (!modelNodes || !modelNodes.length) {\n return template;\n }\n\n addIfNotPresent(modelNodes, 'id', scope.id);\n addIfNotPresent(modelNodes, 'name', scope.name || scope.id);\n\n addValidation();\n alterNgModelAttr();\n addModelOptions();\n addTemplateOptionsAttrs();\n addNgModelElAttrs();\n\n return node.innerHTML;\n\n function addValidation() {\n if (_angularFix2['default'].isDefined(options.validators) || _angularFix2['default'].isDefined(options.validation.messages)) {\n addIfNotPresent(modelNodes, 'formly-custom-validation', '');\n }\n }\n\n function alterNgModelAttr() {\n if (isPropertyAccessor(options.key)) {\n addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key);\n }\n }\n\n function addModelOptions() {\n if (_angularFix2['default'].isDefined(options.modelOptions)) {\n addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions');\n if (options.modelOptions.getterSetter) {\n addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value');\n }\n }\n }\n\n function addTemplateOptionsAttrs() {\n if (!options.templateOptions && !options.expressionProperties) {\n // no need to run these if there are no templateOptions or expressionProperties\n return;\n }\n var to = options.templateOptions || {};\n var ep = options.expressionProperties || {};\n\n var ngModelAttributes = getBuiltInAttributes();\n\n // extend with the user's specifications winning\n _angularFix2['default'].extend(ngModelAttributes, options.ngModelAttrs);\n\n // Feel free to make this more simple :-)\n _angularFix2['default'].forEach(ngModelAttributes, function (val, name) {\n /* eslint complexity:[2, 14] */\n var attrVal = undefined,\n attrName = undefined;\n var ref = 'options.templateOptions[\\'' + name + '\\']';\n var toVal = to[name];\n var epVal = getEpValue(ep, name);\n\n var inTo = _angularFix2['default'].isDefined(toVal);\n var inEp = _angularFix2['default'].isDefined(epVal);\n if (val.value) {\n // I realize this looks backwards, but it's right, trust me...\n attrName = val.value;\n attrVal = name;\n } else if (val.statement && inTo) {\n attrName = val.statement;\n if (_angularFix2['default'].isString(to[name])) {\n attrVal = '$eval(' + ref + ')';\n } else if (_angularFix2['default'].isFunction(to[name])) {\n attrVal = ref + '(model[options.key], options, this, $event)';\n } else {\n throw new Error('options.templateOptions.' + name + ' must be a string or function: ' + JSON.stringify(options));\n }\n } else if (val.bound && inEp) {\n attrName = val.bound;\n attrVal = ref;\n } else if ((val.attribute || val.boolean) && inEp) {\n attrName = val.attribute || val.boolean;\n attrVal = '' + $interpolate.startSymbol() + ref + $interpolate.endSymbol();\n } else if (val.attribute && inTo) {\n attrName = val.attribute;\n attrVal = toVal;\n } else if (val.boolean) {\n if (inTo && !inEp && toVal) {\n attrName = val.boolean;\n attrVal = true;\n } else {\n /* eslint no-empty:0 */\n // empty to illustrate that a boolean will not be added via val.bound\n // if you want it added via val.bound, then put it in expressionProperties\n }\n } else if (val.bound && inTo) {\n attrName = val.bound;\n attrVal = ref;\n }\n\n if (_angularFix2['default'].isDefined(attrName) && _angularFix2['default'].isDefined(attrVal)) {\n addIfNotPresent(modelNodes, attrName, attrVal);\n }\n });\n }\n\n function addNgModelElAttrs() {\n _angularFix2['default'].forEach(options.ngModelElAttrs, function (val, name) {\n addRegardlessOfPresence(modelNodes, name, val);\n });\n }\n }\n\n // Utility functions\n function getNgModelNodes(node, skip) {\n var selectorNot = _angularFix2['default'].isString(skip) ? ':not(' + skip + ')' : '';\n var skipNot = ':not([formly-skip-ng-model-attrs-manipulator])';\n var query = '[ng-model]' + selectorNot + skipNot + ', [data-ng-model]' + selectorNot + skipNot;\n try {\n return node.querySelectorAll(query);\n } catch (e) {\n //this code is needed for IE8, as it does not support the CSS3 ':not' selector\n //it should be removed when IE8 support is dropped\n return getNgModelNodesFallback(node, skip);\n }\n }\n\n function getNgModelNodesFallback(node, skip) {\n var allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]');\n var matchingNgModelNodes = [];\n\n //make sure this array is compatible with NodeList type by adding an 'item' function\n matchingNgModelNodes.item = function (i) {\n return this[i];\n };\n\n for (var i = 0; i < allNgModelNodes.length; i++) {\n var ngModelNode = allNgModelNodes[i];\n if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') && !(_angularFix2['default'].isString(skip) && nodeMatches(ngModelNode, skip))) {\n matchingNgModelNodes.push(ngModelNode);\n }\n }\n\n return matchingNgModelNodes;\n }\n\n function nodeMatches(node, selector) {\n var div = document.createElement('div');\n div.innerHTML = node.outerHTML;\n return div.querySelector(selector);\n }\n\n function getBuiltInAttributes() {\n var ngModelAttributes = {\n focus: {\n attribute: 'formly-focus'\n }\n };\n var boundOnly = [];\n var bothBooleanAndBound = ['required', 'disabled'];\n var bothAttributeAndBound = ['pattern', 'minlength'];\n var statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur'];\n var attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type'];\n if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {\n bothAttributeAndBound.push('maxlength');\n } else {\n boundOnly.push('maxlength');\n }\n\n _angularFix2['default'].forEach(boundOnly, function (item) {\n ngModelAttributes[item] = { bound: 'ng-' + item };\n });\n\n _angularFix2['default'].forEach(bothBooleanAndBound, function (item) {\n ngModelAttributes[item] = { boolean: item, bound: 'ng-' + item };\n });\n\n _angularFix2['default'].forEach(bothAttributeAndBound, function (item) {\n ngModelAttributes[item] = { attribute: item, bound: 'ng-' + item };\n });\n\n _angularFix2['default'].forEach(statementOnly, function (item) {\n var propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1);\n ngModelAttributes[propName] = { statement: 'ng-' + item };\n });\n\n _angularFix2['default'].forEach(attributeOnly, function (item) {\n ngModelAttributes[item] = { attribute: item };\n });\n return ngModelAttributes;\n }\n\n function getEpValue(ep, name) {\n return ep['templateOptions.' + name] || ep['templateOptions[\\'' + name + '\\']'] || ep['templateOptions[\"' + name + '\"]'];\n }\n\n function addIfNotPresent(nodes, attr, val) {\n _angularFix2['default'].forEach(nodes, function (node) {\n if (!node.getAttribute(attr)) {\n node.setAttribute(attr, val);\n }\n });\n }\n\n function addRegardlessOfPresence(nodes, attr, val) {\n _angularFix2['default'].forEach(nodes, function (node) {\n node.setAttribute(attr, val);\n });\n }\n\n function isPropertyAccessor(key) {\n return (0, _otherUtils.contains)(key, '.') || (0, _otherUtils.contains)(key, '[') && (0, _otherUtils.contains)(key, ']');\n }\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./run/formlyNgModelAttrsManipulator.js\n **/","import angular from 'angular-fix'\nimport {contains} from '../other/utils'\n\nexport default addFormlyNgModelAttrsManipulator\n\n// @ngInject\nfunction addFormlyNgModelAttrsManipulator(formlyConfig, $interpolate) {\n if (formlyConfig.extras.disableNgModelAttrsManipulator) {\n return\n }\n formlyConfig.templateManipulators.preWrapper.push(ngModelAttrsManipulator)\n\n\n function ngModelAttrsManipulator(template, options, scope) {\n const node = document.createElement('div')\n const skip = options.extras && options.extras.skipNgModelAttrsManipulator\n if (skip === true) {\n return template\n }\n node.innerHTML = template\n\n const modelNodes = getNgModelNodes(node, skip)\n if (!modelNodes || !modelNodes.length) {\n return template\n }\n\n addIfNotPresent(modelNodes, 'id', scope.id)\n addIfNotPresent(modelNodes, 'name', scope.name || scope.id)\n\n addValidation()\n alterNgModelAttr()\n addModelOptions()\n addTemplateOptionsAttrs()\n addNgModelElAttrs()\n\n\n return node.innerHTML\n\n\n function addValidation() {\n if (angular.isDefined(options.validators) || angular.isDefined(options.validation.messages)) {\n addIfNotPresent(modelNodes, 'formly-custom-validation', '')\n }\n }\n\n function alterNgModelAttr() {\n if (isPropertyAccessor(options.key)) {\n addRegardlessOfPresence(modelNodes, 'ng-model', 'model.' + options.key)\n }\n }\n\n function addModelOptions() {\n if (angular.isDefined(options.modelOptions)) {\n addIfNotPresent(modelNodes, 'ng-model-options', 'options.modelOptions')\n if (options.modelOptions.getterSetter) {\n addRegardlessOfPresence(modelNodes, 'ng-model', 'options.value')\n }\n }\n }\n\n function addTemplateOptionsAttrs() {\n if (!options.templateOptions && !options.expressionProperties) {\n // no need to run these if there are no templateOptions or expressionProperties\n return\n }\n const to = options.templateOptions || {}\n const ep = options.expressionProperties || {}\n\n const ngModelAttributes = getBuiltInAttributes()\n\n // extend with the user's specifications winning\n angular.extend(ngModelAttributes, options.ngModelAttrs)\n\n // Feel free to make this more simple :-)\n angular.forEach(ngModelAttributes, (val, name) => {\n /* eslint complexity:[2, 14] */\n let attrVal, attrName\n const ref = `options.templateOptions['${name}']`\n const toVal = to[name]\n const epVal = getEpValue(ep, name)\n\n const inTo = angular.isDefined(toVal)\n const inEp = angular.isDefined(epVal)\n if (val.value) {\n // I realize this looks backwards, but it's right, trust me...\n attrName = val.value\n attrVal = name\n } else if (val.statement && inTo) {\n attrName = val.statement\n if (angular.isString(to[name])) {\n attrVal = `$eval(${ref})`\n } else if (angular.isFunction(to[name])) {\n attrVal = `${ref}(model[options.key], options, this, $event)`\n } else {\n throw new Error(\n `options.templateOptions.${name} must be a string or function: ${JSON.stringify(options)}`\n )\n }\n } else if (val.bound && inEp) {\n attrName = val.bound\n attrVal = ref\n } else if ((val.attribute || val.boolean) && inEp) {\n attrName = val.attribute || val.boolean\n attrVal = `${$interpolate.startSymbol()}${ref}${$interpolate.endSymbol()}`\n } else if (val.attribute && inTo) {\n attrName = val.attribute\n attrVal = toVal\n } else if (val.boolean) {\n if (inTo && !inEp && toVal) {\n attrName = val.boolean\n attrVal = true\n } else {\n /* eslint no-empty:0 */\n // empty to illustrate that a boolean will not be added via val.bound\n // if you want it added via val.bound, then put it in expressionProperties\n }\n } else if (val.bound && inTo) {\n attrName = val.bound\n attrVal = ref\n }\n\n if (angular.isDefined(attrName) && angular.isDefined(attrVal)) {\n addIfNotPresent(modelNodes, attrName, attrVal)\n }\n })\n }\n\n function addNgModelElAttrs() {\n angular.forEach(options.ngModelElAttrs, (val, name) => {\n addRegardlessOfPresence(modelNodes, name, val)\n })\n }\n }\n\n // Utility functions\n function getNgModelNodes(node, skip) {\n const selectorNot = angular.isString(skip) ? `:not(${skip})` : ''\n const skipNot = ':not([formly-skip-ng-model-attrs-manipulator])'\n const query = `[ng-model]${selectorNot}${skipNot}, [data-ng-model]${selectorNot}${skipNot}`\n try {\n return node.querySelectorAll(query)\n } catch (e) {\n //this code is needed for IE8, as it does not support the CSS3 ':not' selector\n //it should be removed when IE8 support is dropped\n return getNgModelNodesFallback(node, skip)\n }\n }\n\n function getNgModelNodesFallback(node, skip) {\n const allNgModelNodes = node.querySelectorAll('[ng-model], [data-ng-model]')\n const matchingNgModelNodes = []\n\n //make sure this array is compatible with NodeList type by adding an 'item' function\n matchingNgModelNodes.item = function(i) {\n return this[i]\n }\n\n for (let i = 0; i < allNgModelNodes.length; i++) {\n const ngModelNode = allNgModelNodes[i]\n if (!ngModelNode.hasAttribute('formly-skip-ng-model-attrs-manipulator') &&\n !(angular.isString(skip) && nodeMatches(ngModelNode, skip))) {\n matchingNgModelNodes.push(ngModelNode)\n }\n }\n\n return matchingNgModelNodes\n }\n\n function nodeMatches(node, selector) {\n const div = document.createElement('div')\n div.innerHTML = node.outerHTML\n return div.querySelector(selector)\n }\n\n function getBuiltInAttributes() {\n const ngModelAttributes = {\n focus: {\n attribute: 'formly-focus',\n },\n }\n const boundOnly = []\n const bothBooleanAndBound = ['required', 'disabled']\n const bothAttributeAndBound = ['pattern', 'minlength']\n const statementOnly = ['change', 'keydown', 'keyup', 'keypress', 'click', 'focus', 'blur']\n const attributeOnly = ['placeholder', 'min', 'max', 'step', 'tabindex', 'type']\n if (formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound) {\n bothAttributeAndBound.push('maxlength')\n } else {\n boundOnly.push('maxlength')\n }\n\n angular.forEach(boundOnly, item => {\n ngModelAttributes[item] = {bound: 'ng-' + item}\n })\n\n angular.forEach(bothBooleanAndBound, item => {\n ngModelAttributes[item] = {boolean: item, bound: 'ng-' + item}\n })\n\n angular.forEach(bothAttributeAndBound, item => {\n ngModelAttributes[item] = {attribute: item, bound: 'ng-' + item}\n })\n\n angular.forEach(statementOnly, item => {\n const propName = 'on' + item.substr(0, 1).toUpperCase() + item.substr(1)\n ngModelAttributes[propName] = {statement: 'ng-' + item}\n })\n\n angular.forEach(attributeOnly, item => {\n ngModelAttributes[item] = {attribute: item}\n })\n return ngModelAttributes\n }\n\n function getEpValue(ep, name) {\n return ep['templateOptions.' + name] ||\n ep[`templateOptions['${name}']`] ||\n ep[`templateOptions[\"${name}\"]`]\n }\n\n function addIfNotPresent(nodes, attr, val) {\n angular.forEach(nodes, node => {\n if (!node.getAttribute(attr)) {\n node.setAttribute(attr, val)\n }\n })\n }\n\n function addRegardlessOfPresence(nodes, attr, val) {\n angular.forEach(nodes, node => {\n node.setAttribute(attr, val)\n })\n }\n\n function isPropertyAccessor(key) {\n return contains(key, '.') || (contains(key, '[') && contains(key, ']'))\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./run/formlyNgModelAttrsManipulator.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _otherUtils = require('../other/utils');\n\nvar _otherUtils2 = _interopRequireDefault(_otherUtils);\n\nexports['default'] = formlyUtil;\n\n// @ngInject\nfunction formlyUtil() {\n return _otherUtils2['default'];\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./services/formlyUtil.js\n **/","import utils from '../other/utils'\n\nexport default formlyUtil\n\n// @ngInject\nfunction formlyUtil() {\n return utils\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./services/formlyUtil.js\n **/","'use strict';\n\nObject.defineProperty(exports, '__esModule', {\n value: true\n});\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\nexports['default'] = formlyWarn;\n\n// @ngInject\nfunction formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) {\n return function warn() {\n if (!formlyConfig.disableWarnings) {\n var args = Array.prototype.slice.call(arguments);\n var warnInfoSlug = args.shift();\n args.unshift('Formly Warning:');\n args.push('' + formlyErrorAndWarningsUrlPrefix + warnInfoSlug);\n $log.warn.apply($log, _toConsumableArray(args));\n }\n };\n}\nmodule.exports = exports['default'];\n\n\n/** WEBPACK FOOTER **\n ** ./services/formlyWarn.js\n **/","export default formlyWarn\n\n// @ngInject\nfunction formlyWarn(formlyConfig, formlyErrorAndWarningsUrlPrefix, $log) {\n return function warn() {\n if (!formlyConfig.disableWarnings) {\n const args = Array.prototype.slice.call(arguments)\n const warnInfoSlug = args.shift()\n args.unshift('Formly Warning:')\n args.push(`${formlyErrorAndWarningsUrlPrefix}${warnInfoSlug}`)\n $log.warn(...args)\n }\n }\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ../~/eslint-loader?configFile=./other/src.eslintrc!./services/formlyWarn.js\n **/","module.exports = __WEBPACK_EXTERNAL_MODULE_18__;\n\n\n/*****************\n ** WEBPACK FOOTER\n ** external \"angular\"\n ** module id = 18\n ** module chunks = 0\n **/"],"sourceRoot":""} \ No newline at end of file diff --git a/package.json b/package.json index 890d705f..aeafd825 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "angular-formly", - "version": "0.0.0-semantically-released.0", + "version": "8.1.0", "author": "Astrism ", "contributors": [ "Astrism ", @@ -119,4 +119,4 @@ "silent": false } } -} +} \ No newline at end of file