@sankhyalabs/ezui 1.1.75 → 1.1.78

package/dist/cjs/ez-form.cjs.entry.js

@@ -0,0 +1,1838 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index$1 = require('./index-4e4bae01.js');
+const DataUnit = require('./DataUnit-fdd7c70e.js');
+const index = require('./index-40ebb2be.js');
+const ApplicationUtils = require('./ApplicationUtils-d1c1db56.js');
+const DateUtils = require('./DateUtils-716769e0.js');
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+/**
+ * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
+ *
+ * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
+ * during build.
+ * @param {number} code
+ */
+function formatProdErrorMessage(code) {
+  return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or " + 'use the non-minified dev environment for full errors. ';
+}
+
+// Inlined version of the `symbol-observable` polyfill
+var $$observable = (function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+})();
+
+/**
+ * These are private action types reserved by Redux.
+ * For any unknown actions, you must return the current state.
+ * If the current state is undefined, you must return the initial state.
+ * Do not reference these action types directly in your code.
+ */
+var randomString = function randomString() {
+  return Math.random().toString(36).substring(7).split('').join('.');
+};
+
+var ActionTypes = {
+  INIT: "@@redux/INIT" + randomString(),
+  REPLACE: "@@redux/REPLACE" + randomString(),
+  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
+    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
+  }
+};
+
+/**
+ * @param {any} obj The object to inspect.
+ * @returns {boolean} True if the argument appears to be a plain object.
+ */
+function isPlainObject(obj) {
+  if (typeof obj !== 'object' || obj === null) return false;
+  var proto = obj;
+
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Object.getPrototypeOf(obj) === proto;
+}
+
+/**
+ * Creates a Redux store that holds the state tree.
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+
+function createStore(reducer, preloadedState, enhancer) {
+  var _ref2;
+
+  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
+    throw new Error(formatProdErrorMessage(0) );
+  }
+
+  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
+    enhancer = preloadedState;
+    preloadedState = undefined;
+  }
+
+  if (typeof enhancer !== 'undefined') {
+    if (typeof enhancer !== 'function') {
+      throw new Error(formatProdErrorMessage(1) );
+    }
+
+    return enhancer(createStore)(reducer, preloadedState);
+  }
+
+  if (typeof reducer !== 'function') {
+    throw new Error(formatProdErrorMessage(2) );
+  }
+
+  var currentReducer = reducer;
+  var currentState = preloadedState;
+  var currentListeners = [];
+  var nextListeners = currentListeners;
+  var isDispatching = false;
+  /**
+   * This makes a shallow copy of currentListeners so we can use
+   * nextListeners as a temporary list while dispatching.
+   *
+   * This prevents any bugs around consumers calling
+   * subscribe/unsubscribe in the middle of a dispatch.
+   */
+
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = currentListeners.slice();
+    }
+  }
+  /**
+   * Reads the state tree managed by the store.
+   *
+   * @returns {any} The current state tree of your application.
+   */
+
+
+  function getState() {
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(3) );
+    }
+
+    return currentState;
+  }
+  /**
+   * Adds a change listener. It will be called any time an action is dispatched,
+   * and some part of the state tree may potentially have changed. You may then
+   * call `getState()` to read the current state tree inside the callback.
+   *
+   * You may call `dispatch()` from a change listener, with the following
+   * caveats:
+   *
+   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+   * If you subscribe or unsubscribe while the listeners are being invoked, this
+   * will not have any effect on the `dispatch()` that is currently in progress.
+   * However, the next `dispatch()` call, whether nested or not, will use a more
+   * recent snapshot of the subscription list.
+   *
+   * 2. The listener should not expect to see all state changes, as the state
+   * might have been updated multiple times during a nested `dispatch()` before
+   * the listener is called. It is, however, guaranteed that all subscribers
+   * registered before the `dispatch()` started will be called with the latest
+   * state by the time it exits.
+   *
+   * @param {Function} listener A callback to be invoked on every dispatch.
+   * @returns {Function} A function to remove this change listener.
+   */
+
+
+  function subscribe(listener) {
+    if (typeof listener !== 'function') {
+      throw new Error(formatProdErrorMessage(4) );
+    }
+
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(5) );
+    }
+
+    var isSubscribed = true;
+    ensureCanMutateNextListeners();
+    nextListeners.push(listener);
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return;
+      }
+
+      if (isDispatching) {
+        throw new Error(formatProdErrorMessage(6) );
+      }
+
+      isSubscribed = false;
+      ensureCanMutateNextListeners();
+      var index = nextListeners.indexOf(listener);
+      nextListeners.splice(index, 1);
+      currentListeners = null;
+    };
+  }
+  /**
+   * Dispatches an action. It is the only way to trigger a state change.
+   *
+   * The `reducer` function, used to create the store, will be called with the
+   * current state tree and the given `action`. Its return value will
+   * be considered the **next** state of the tree, and the change listeners
+   * will be notified.
+   *
+   * The base implementation only supports plain object actions. If you want to
+   * dispatch a Promise, an Observable, a thunk, or something else, you need to
+   * wrap your store creating function into the corresponding middleware. For
+   * example, see the documentation for the `redux-thunk` package. Even the
+   * middleware will eventually dispatch plain object actions using this method.
+   *
+   * @param {Object} action A plain object representing “what changed”. It is
+   * a good idea to keep actions serializable so you can record and replay user
+   * sessions, or use the time travelling `redux-devtools`. An action must have
+   * a `type` property which may not be `undefined`. It is a good idea to use
+   * string constants for action types.
+   *
+   * @returns {Object} For convenience, the same action object you dispatched.
+   *
+   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+   * return something else (for example, a Promise you can await).
+   */
+
+
+  function dispatch(action) {
+    if (!isPlainObject(action)) {
+      throw new Error(formatProdErrorMessage(7) );
+    }
+
+    if (typeof action.type === 'undefined') {
+      throw new Error(formatProdErrorMessage(8) );
+    }
+
+    if (isDispatching) {
+      throw new Error(formatProdErrorMessage(9) );
+    }
+
+    try {
+      isDispatching = true;
+      currentState = currentReducer(currentState, action);
+    } finally {
+      isDispatching = false;
+    }
+
+    var listeners = currentListeners = nextListeners;
+
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+
+    return action;
+  }
+  /**
+   * Replaces the reducer currently used by the store to calculate the state.
+   *
+   * You might need this if your app implements code splitting and you want to
+   * load some of the reducers dynamically. You might also need this if you
+   * implement a hot reloading mechanism for Redux.
+   *
+   * @param {Function} nextReducer The reducer for the store to use instead.
+   * @returns {void}
+   */
+
+
+  function replaceReducer(nextReducer) {
+    if (typeof nextReducer !== 'function') {
+      throw new Error(formatProdErrorMessage(10) );
+    }
+
+    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
+    // Any reducers that existed in both the new and old rootReducer
+    // will receive the previous state. This effectively populates
+    // the new state tree with any relevant data from the old one.
+
+    dispatch({
+      type: ActionTypes.REPLACE
+    });
+  }
+  /**
+   * Interoperability point for observable/reactive libraries.
+   * @returns {observable} A minimal observable of state changes.
+   * For more information, see the observable proposal:
+   * https://github.com/tc39/proposal-observable
+   */
+
+
+  function observable() {
+    var _ref;
+
+    var outerSubscribe = subscribe;
+    return _ref = {
+      /**
+       * The minimal observable subscription method.
+       * @param {Object} observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns {subscription} An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe: function subscribe(observer) {
+        if (typeof observer !== 'object' || observer === null) {
+          throw new Error(formatProdErrorMessage(11) );
+        }
+
+        function observeState() {
+          if (observer.next) {
+            observer.next(getState());
+          }
+        }
+
+        observeState();
+        var unsubscribe = outerSubscribe(observeState);
+        return {
+          unsubscribe: unsubscribe
+        };
+      }
+    }, _ref[$$observable] = function () {
+      return this;
+    }, _ref;
+  } // When a store is created, an "INIT" action is dispatched so that every
+  // reducer returns their initial state. This effectively populates
+  // the initial state tree.
+
+
+  dispatch({
+    type: ActionTypes.INIT
+  });
+  return _ref2 = {
+    dispatch: dispatch,
+    subscribe: subscribe,
+    getState: getState,
+    replaceReducer: replaceReducer
+  }, _ref2[$$observable] = observable, _ref2;
+}
+
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach(function (key) {
+    var reducer = reducers[key];
+    var initialState = reducer(undefined, {
+      type: ActionTypes.INIT
+    });
+
+    if (typeof initialState === 'undefined') {
+      throw new Error(formatProdErrorMessage(12) );
+    }
+
+    if (typeof reducer(undefined, {
+      type: ActionTypes.PROBE_UNKNOWN_ACTION()
+    }) === 'undefined') {
+      throw new Error(formatProdErrorMessage(13) );
+    }
+  });
+}
+/**
+ * Turns an object whose values are different reducer functions, into a single
+ * reducer function. It will call every child reducer, and gather their results
+ * into a single state object, whose keys correspond to the keys of the passed
+ * reducer functions.
+ *
+ * @param {Object} reducers An object whose values correspond to different
+ * reducer functions that need to be combined into one. One handy way to obtain
+ * it is to use ES6 `import * as reducers` syntax. The reducers may never return
+ * undefined for any action. Instead, they should return their initial state
+ * if the state passed to them was undefined, and the current state for any
+ * unrecognized action.
+ *
+ * @returns {Function} A reducer function that invokes every reducer inside the
+ * passed object, and builds a state object with the same shape.
+ */
+
+
+function combineReducers(reducers) {
+  var reducerKeys = Object.keys(reducers);
+  var finalReducers = {};
+
+  for (var i = 0; i < reducerKeys.length; i++) {
+    var key = reducerKeys[i];
+
+    if (typeof reducers[key] === 'function') {
+      finalReducers[key] = reducers[key];
+    }
+  }
+
+  var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same
+
+  var shapeAssertionError;
+
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
+  }
+
+  return function combination(state, action) {
+    if (state === void 0) {
+      state = {};
+    }
+
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
+    }
+
+    var hasChanged = false;
+    var nextState = {};
+
+    for (var _i = 0; _i < finalReducerKeys.length; _i++) {
+      var _key = finalReducerKeys[_i];
+      var reducer = finalReducers[_key];
+      var previousStateForKey = state[_key];
+      var nextStateForKey = reducer(previousStateForKey, action);
+
+      if (typeof nextStateForKey === 'undefined') {
+        throw new Error(formatProdErrorMessage(14) );
+      }
+
+      nextState[_key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function.
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+function compose() {
+  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
+    funcs[_key] = arguments[_key];
+  }
+
+  if (funcs.length === 0) {
+    return function (arg) {
+      return arg;
+    };
+  }
+
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+
+  return funcs.reduce(function (a, b) {
+    return function () {
+      return a(b.apply(void 0, arguments));
+    };
+  });
+}
+
+/**
+ * Creates a store enhancer that applies middleware to the dispatch method
+ * of the Redux store. This is handy for a variety of tasks, such as expressing
+ * asynchronous actions in a concise manner, or logging every action payload.
+ *
+ * See `redux-thunk` package as an example of the Redux middleware.
+ *
+ * Because middleware is potentially asynchronous, this should be the first
+ * store enhancer in the composition chain.
+ *
+ * Note that each middleware will be given the `dispatch` and `getState` functions
+ * as named arguments.
+ *
+ * @param {...Function} middlewares The middleware chain to be applied.
+ * @returns {Function} A store enhancer applying the middleware.
+ */
+
+function applyMiddleware() {
+  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
+    middlewares[_key] = arguments[_key];
+  }
+
+  return function (createStore) {
+    return function () {
+      var store = createStore.apply(void 0, arguments);
+
+      var _dispatch = function dispatch() {
+        throw new Error(formatProdErrorMessage(15) );
+      };
+
+      var middlewareAPI = {
+        getState: store.getState,
+        dispatch: function dispatch() {
+          return _dispatch.apply(void 0, arguments);
+        }
+      };
+      var chain = middlewares.map(function (middleware) {
+        return middleware(middlewareAPI);
+      });
+      _dispatch = compose.apply(void 0, chain)(store.dispatch);
+      return _objectSpread2(_objectSpread2({}, store), {}, {
+        dispatch: _dispatch
+      });
+    };
+  };
+}
+
+/** A function that accepts a potential "extra argument" value to be injected later,
+ * and returns an instance of the thunk middleware that uses that value
+ */
+function createThunkMiddleware(extraArgument) {
+  // Standard Redux middleware definition pattern:
+  // See: https://redux.js.org/tutorials/fundamentals/part-4-store#writing-custom-middleware
+  var middleware = function middleware(_ref) {
+    var dispatch = _ref.dispatch,
+        getState = _ref.getState;
+    return function (next) {
+      return function (action) {
+        // The thunk middleware looks for any functions that were passed to `store.dispatch`.
+        // If this "action" is really a function, call it and return the result.
+        if (typeof action === 'function') {
+          // Inject the store's `dispatch` and `getState` methods, as well as any "extra arg"
+          return action(dispatch, getState, extraArgument);
+        } // Otherwise, pass the action down the middleware chain as usual
+
+
+        return next(action);
+      };
+    };
+  };
+
+  return middleware;
+}
+
+var thunk = createThunkMiddleware(); // Attach the factory function so users can create a customized version
+// with whatever "extra arg" they want to inject into their thunks
+
+thunk.withExtraArgument = createThunkMiddleware;
+
+var actions = index.createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ActionCreators = exports.ActionTypes = void 0;
+var ActionTypes = {
+  UNDO: '@@redux-undo/UNDO',
+  REDO: '@@redux-undo/REDO',
+  JUMP_TO_FUTURE: '@@redux-undo/JUMP_TO_FUTURE',
+  JUMP_TO_PAST: '@@redux-undo/JUMP_TO_PAST',
+  JUMP: '@@redux-undo/JUMP',
+  CLEAR_HISTORY: '@@redux-undo/CLEAR_HISTORY'
+};
+exports.ActionTypes = ActionTypes;
+var ActionCreators = {
+  undo: function undo() {
+    return {
+      type: ActionTypes.UNDO
+    };
+  },
+  redo: function redo() {
+    return {
+      type: ActionTypes.REDO
+    };
+  },
+  jumpToFuture: function jumpToFuture(index) {
+    return {
+      type: ActionTypes.JUMP_TO_FUTURE,
+      index: index
+    };
+  },
+  jumpToPast: function jumpToPast(index) {
+    return {
+      type: ActionTypes.JUMP_TO_PAST,
+      index: index
+    };
+  },
+  jump: function jump(index) {
+    return {
+      type: ActionTypes.JUMP,
+      index: index
+    };
+  },
+  clearHistory: function clearHistory() {
+    return {
+      type: ActionTypes.CLEAR_HISTORY
+    };
+  }
+};
+exports.ActionCreators = ActionCreators;
+});
+
+var helpers = index.createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseActions = parseActions;
+exports.isHistory = isHistory;
+exports.includeAction = includeAction;
+exports.excludeAction = excludeAction;
+exports.combineFilters = combineFilters;
+exports.groupByActionTypes = groupByActionTypes;
+exports.newHistory = newHistory;
+
+// parseActions helper: takes a string (or array)
+//                      and makes it an array if it isn't yet
+function parseActions(rawActions) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  if (Array.isArray(rawActions)) {
+    return rawActions;
+  } else if (typeof rawActions === 'string') {
+    return [rawActions];
+  }
+
+  return defaultValue;
+} // isHistory helper: check for a valid history object
+
+
+function isHistory(history) {
+  return typeof history.present !== 'undefined' && typeof history.future !== 'undefined' && typeof history.past !== 'undefined' && Array.isArray(history.future) && Array.isArray(history.past);
+} // includeAction helper: whitelist actions to be added to the history
+
+
+function includeAction(rawActions) {
+  var actions = parseActions(rawActions);
+  return function (action) {
+    return actions.indexOf(action.type) >= 0;
+  };
+} // excludeAction helper: blacklist actions from being added to the history
+
+
+function excludeAction(rawActions) {
+  var actions = parseActions(rawActions);
+  return function (action) {
+    return actions.indexOf(action.type) < 0;
+  };
+} // combineFilters helper: combine multiple filters to one
+
+
+function combineFilters() {
+  for (var _len = arguments.length, filters = new Array(_len), _key = 0; _key < _len; _key++) {
+    filters[_key] = arguments[_key];
+  }
+
+  return filters.reduce(function (prev, curr) {
+    return function (action, currentState, previousHistory) {
+      return prev(action, currentState, previousHistory) && curr(action, currentState, previousHistory);
+    };
+  }, function () {
+    return true;
+  });
+}
+
+function groupByActionTypes(rawActions) {
+  var actions = parseActions(rawActions);
+  return function (action) {
+    return actions.indexOf(action.type) >= 0 ? action.type : null;
+  };
+}
+
+function newHistory(past, present, future) {
+  var group = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  return {
+    past: past,
+    present: present,
+    future: future,
+    group: group,
+    _latestUnfiltered: present,
+    index: past.length,
+    limit: past.length + future.length + 1
+  };
+}
+});
+
+var debug = index.createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.set = set;
+exports.start = start;
+exports.end = end;
+exports.log = log;
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+var __DEBUG__;
+
+var displayBuffer;
+var colors = {
+  prevState: '#9E9E9E',
+  action: '#03A9F4',
+  nextState: '#4CAF50'
+};
+/* istanbul ignore next: debug messaging is not tested */
+
+function initBuffer() {
+  displayBuffer = {
+    header: [],
+    prev: [],
+    action: [],
+    next: [],
+    msgs: []
+  };
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function printBuffer() {
+  var _displayBuffer = displayBuffer,
+      header = _displayBuffer.header,
+      prev = _displayBuffer.prev,
+      next = _displayBuffer.next,
+      action = _displayBuffer.action,
+      msgs = _displayBuffer.msgs;
+
+  if (console.group) {
+    var _console, _console2, _console3, _console4, _console5;
+
+    (_console = console).groupCollapsed.apply(_console, _toConsumableArray(header));
+
+    (_console2 = console).log.apply(_console2, _toConsumableArray(prev));
+
+    (_console3 = console).log.apply(_console3, _toConsumableArray(action));
+
+    (_console4 = console).log.apply(_console4, _toConsumableArray(next));
+
+    (_console5 = console).log.apply(_console5, _toConsumableArray(msgs));
+
+    console.groupEnd();
+  } else {
+    var _console6, _console7, _console8, _console9, _console10;
+
+    (_console6 = console).log.apply(_console6, _toConsumableArray(header));
+
+    (_console7 = console).log.apply(_console7, _toConsumableArray(prev));
+
+    (_console8 = console).log.apply(_console8, _toConsumableArray(action));
+
+    (_console9 = console).log.apply(_console9, _toConsumableArray(next));
+
+    (_console10 = console).log.apply(_console10, _toConsumableArray(msgs));
+  }
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function colorFormat(text, color, obj) {
+  return ["%c".concat(text), "color: ".concat(color, "; font-weight: bold"), obj];
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function start(action, state) {
+  initBuffer();
+
+  if (__DEBUG__) {
+    if (console.group) {
+      displayBuffer.header = ['%credux-undo', 'font-style: italic', 'action', action.type];
+      displayBuffer.action = colorFormat('action', colors.action, action);
+      displayBuffer.prev = colorFormat('prev history', colors.prevState, state);
+    } else {
+      displayBuffer.header = ['redux-undo action', action.type];
+      displayBuffer.action = ['action', action];
+      displayBuffer.prev = ['prev history', state];
+    }
+  }
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function end(nextState) {
+  if (__DEBUG__) {
+    if (console.group) {
+      displayBuffer.next = colorFormat('next history', colors.nextState, nextState);
+    } else {
+      displayBuffer.next = ['next history', nextState];
+    }
+
+    printBuffer();
+  }
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function log() {
+  if (__DEBUG__) {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    displayBuffer.msgs = displayBuffer.msgs.concat([].concat(args, ['\n']));
+  }
+}
+/* istanbul ignore next: debug messaging is not tested */
+
+
+function set(debug) {
+  __DEBUG__ = debug;
+}
+});
+
+var reducer = index.createCommonjsModule(function (module, exports) {
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = undoable;
+
+var debug$1 = _interopRequireWildcard(debug);
+
+
+
+
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function createHistory(state, ignoreInitialState) {
+  // ignoreInitialState essentially prevents the user from undoing to the
+  // beginning, in the case that the undoable reducer handles initialization
+  // in a way that can't be redone simply
+  var history = (0, helpers.newHistory)([], state, []);
+
+  if (ignoreInitialState) {
+    history._latestUnfiltered = null;
+  }
+
+  return history;
+} // insert: insert `state` into history, which means adding the current state
+//         into `past`, setting the new `state` as `present` and erasing
+//         the `future`.
+
+
+function insert(history, state, limit, group) {
+  var lengthWithoutFuture = history.past.length + 1;
+  debug$1.log('inserting', state);
+  debug$1.log('new free: ', limit - lengthWithoutFuture);
+  var past = history.past,
+      _latestUnfiltered = history._latestUnfiltered;
+  var isHistoryOverflow = limit && limit <= lengthWithoutFuture;
+  var pastSliced = past.slice(isHistoryOverflow ? 1 : 0);
+  var newPast = _latestUnfiltered != null ? [].concat(_toConsumableArray(pastSliced), [_latestUnfiltered]) : pastSliced;
+  return (0, helpers.newHistory)(newPast, state, [], group);
+} // jumpToFuture: jump to requested index in future history
+
+
+function jumpToFuture(history, index) {
+  if (index < 0 || index >= history.future.length) return history;
+  var past = history.past,
+      future = history.future,
+      _latestUnfiltered = history._latestUnfiltered;
+  var newPast = [].concat(_toConsumableArray(past), [_latestUnfiltered], _toConsumableArray(future.slice(0, index)));
+  var newPresent = future[index];
+  var newFuture = future.slice(index + 1);
+  return (0, helpers.newHistory)(newPast, newPresent, newFuture);
+} // jumpToPast: jump to requested index in past history
+
+
+function jumpToPast(history, index) {
+  if (index < 0 || index >= history.past.length) return history;
+  var past = history.past,
+      future = history.future,
+      _latestUnfiltered = history._latestUnfiltered;
+  var newPast = past.slice(0, index);
+  var newFuture = [].concat(_toConsumableArray(past.slice(index + 1)), [_latestUnfiltered], _toConsumableArray(future));
+  var newPresent = past[index];
+  return (0, helpers.newHistory)(newPast, newPresent, newFuture);
+} // jump: jump n steps in the past or forward
+
+
+function jump(history, n) {
+  if (n > 0) return jumpToFuture(history, n - 1);
+  if (n < 0) return jumpToPast(history, history.past.length + n);
+  return history;
+} // helper to dynamically match in the reducer's switch-case
+
+
+function actionTypeAmongClearHistoryType(actionType, clearHistoryType) {
+  return clearHistoryType.indexOf(actionType) > -1 ? actionType : !actionType;
+} // redux-undo higher order reducer
+
+
+function undoable(reducer) {
+  var rawConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  debug$1.set(rawConfig.debug);
+
+  var config = _objectSpread({
+    limit: undefined,
+    filter: function filter() {
+      return true;
+    },
+    groupBy: function groupBy() {
+      return null;
+    },
+    undoType: actions.ActionTypes.UNDO,
+    redoType: actions.ActionTypes.REDO,
+    jumpToPastType: actions.ActionTypes.JUMP_TO_PAST,
+    jumpToFutureType: actions.ActionTypes.JUMP_TO_FUTURE,
+    jumpType: actions.ActionTypes.JUMP,
+    neverSkipReducer: false,
+    ignoreInitialState: false,
+    syncFilter: false
+  }, rawConfig, {
+    initTypes: (0, helpers.parseActions)(rawConfig.initTypes, ['@@redux-undo/INIT']),
+    clearHistoryType: (0, helpers.parseActions)(rawConfig.clearHistoryType, [actions.ActionTypes.CLEAR_HISTORY])
+  }); // Allows the user to call the reducer with redux-undo specific actions
+
+
+  var skipReducer = config.neverSkipReducer ? function (res, action) {
+    for (var _len = arguments.length, slices = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      slices[_key - 2] = arguments[_key];
+    }
+
+    return _objectSpread({}, res, {
+      present: reducer.apply(void 0, [res.present, action].concat(slices))
+    });
+  } : function (res) {
+    return res;
+  };
+  var initialState;
+  return function () {
+    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+    var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    debug$1.start(action, state);
+    var history = state;
+
+    for (var _len2 = arguments.length, slices = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+      slices[_key2 - 2] = arguments[_key2];
+    }
+
+    if (!initialState) {
+      debug$1.log('history is uninitialized');
+
+      if (state === undefined) {
+        var createHistoryAction = {
+          type: '@@redux-undo/CREATE_HISTORY'
+        };
+        var start = reducer.apply(void 0, [state, createHistoryAction].concat(slices));
+        history = createHistory(start, config.ignoreInitialState);
+        debug$1.log('do not set initialState on probe actions');
+        debug$1.end(history);
+        return history;
+      } else if ((0, helpers.isHistory)(state)) {
+        history = initialState = config.ignoreInitialState ? state : (0, helpers.newHistory)(state.past, state.present, state.future);
+        debug$1.log('initialHistory initialized: initialState is a history', initialState);
+      } else {
+        history = initialState = createHistory(state, config.ignoreInitialState);
+        debug$1.log('initialHistory initialized: initialState is not a history', initialState);
+      }
+    }
+
+    var res;
+
+    switch (action.type) {
+      case undefined:
+        return history;
+
+      case config.undoType:
+        res = jump(history, -1);
+        debug$1.log('perform undo');
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      case config.redoType:
+        res = jump(history, 1);
+        debug$1.log('perform redo');
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      case config.jumpToPastType:
+        res = jumpToPast(history, action.index);
+        debug$1.log("perform jumpToPast to ".concat(action.index));
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      case config.jumpToFutureType:
+        res = jumpToFuture(history, action.index);
+        debug$1.log("perform jumpToFuture to ".concat(action.index));
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      case config.jumpType:
+        res = jump(history, action.index);
+        debug$1.log("perform jump to ".concat(action.index));
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      case actionTypeAmongClearHistoryType(action.type, config.clearHistoryType):
+        res = createHistory(history.present, config.ignoreInitialState);
+        debug$1.log('perform clearHistory');
+        debug$1.end(res);
+        return skipReducer.apply(void 0, [res, action].concat(slices));
+
+      default:
+        res = reducer.apply(void 0, [history.present, action].concat(slices));
+
+        if (config.initTypes.some(function (actionType) {
+          return actionType === action.type;
+        })) {
+          debug$1.log('reset history due to init action');
+          debug$1.end(initialState);
+          return initialState;
+        }
+
+        if (history._latestUnfiltered === res) {
+          // Don't handle this action. Do not call debug.end here,
+          // because this action should not produce side effects to the console
+          return history;
+        }
+        /* eslint-disable-next-line no-case-declarations */
+
+
+        var filtered = typeof config.filter === 'function' && !config.filter(action, res, history);
+
+        if (filtered) {
+          // if filtering an action, merely update the present
+          var filteredState = (0, helpers.newHistory)(history.past, res, history.future, history.group);
+
+          if (!config.syncFilter) {
+            filteredState._latestUnfiltered = history._latestUnfiltered;
+          }
+
+          debug$1.log('filter ignored action, not storing it in past');
+          debug$1.end(filteredState);
+          return filteredState;
+        }
+        /* eslint-disable-next-line no-case-declarations */
+
+
+        var group = config.groupBy(action, res, history);
+
+        if (group != null && group === history.group) {
+          // if grouping with the previous action, only update the present
+          var groupedState = (0, helpers.newHistory)(history.past, res, history.future, history.group);
+          debug$1.log('groupBy grouped the action with the previous action');
+          debug$1.end(groupedState);
+          return groupedState;
+        } // If the action wasn't filtered or grouped, insert normally
+
+
+        history = insert(history, res, config.limit, group);
+        debug$1.log('inserted new state into history');
+        debug$1.end(history);
+        return history;
+    }
+  };
+}
+});
+
+var lib = index.createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ActionTypes", {
+  enumerable: true,
+  get: function get() {
+    return actions.ActionTypes;
+  }
+});
+Object.defineProperty(exports, "ActionCreators", {
+  enumerable: true,
+  get: function get() {
+    return actions.ActionCreators;
+  }
+});
+Object.defineProperty(exports, "parseActions", {
+  enumerable: true,
+  get: function get() {
+    return helpers.parseActions;
+  }
+});
+Object.defineProperty(exports, "isHistory", {
+  enumerable: true,
+  get: function get() {
+    return helpers.isHistory;
+  }
+});
+Object.defineProperty(exports, "includeAction", {
+  enumerable: true,
+  get: function get() {
+    return helpers.includeAction;
+  }
+});
+Object.defineProperty(exports, "excludeAction", {
+  enumerable: true,
+  get: function get() {
+    return helpers.excludeAction;
+  }
+});
+Object.defineProperty(exports, "combineFilters", {
+  enumerable: true,
+  get: function get() {
+    return helpers.combineFilters;
+  }
+});
+Object.defineProperty(exports, "groupByActionTypes", {
+  enumerable: true,
+  get: function get() {
+    return helpers.groupByActionTypes;
+  }
+});
+Object.defineProperty(exports, "newHistory", {
+  enumerable: true,
+  get: function get() {
+    return helpers.newHistory;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _reducer["default"];
+  }
+});
+
+
+
+
+
+var _reducer = _interopRequireDefault(reducer);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+});
+
+const undoable = /*@__PURE__*/index.getDefaultExportFromCjs(lib);
+
+const inicialHistState = {
+  currentTabIndex: {},
+  currentRecordIndex: {},
+  changes: {},
+  collapsedGroups: {},
+  newRecordIndex: {}
+};
+const inicialNonHistState = {
+  dataLoading: {},
+  invalidFields: {},
+  visibleButtons: {
+    previousVisible: true,
+    nextVisible: true,
+    addVisible: true,
+    removeVisible: true,
+    saveVisible: true,
+    cancelVisible: true,
+    reloadVisible: false
+  }
+};
+function formReducer(state = inicialHistState, action) {
+  switch (action.type) {
+    case "FORM/COLLAPSEGROUP":
+      return collapseGroup(state, action.payload);
+    case "FORM/CHANGETAB":
+      return changeTab(state, action.payload.formId, action.payload.index);
+    case "FORM/NAVIGATE":
+      return navigate(state, action.payload);
+    case "FORM/INSERT":
+      return insertRecord(state, action.payload);
+    case "FORM/CHANGEFIELD":
+      return changeFieldValue(state, action.payload);
+    case "FORM/CLEAREDITION":
+      return clearEdition(state, action.payload);
+    case "FORM/INVALIDFIELD":
+      return navigateToInvalid(state, action.payload);
+    default:
+      return state;
+  }
+}
+function formNonHistoricReducer(state = inicialNonHistState, action) {
+  switch (action.type) {
+    case "FORM/DATALOADING":
+      return dataLoading(state, action.payload);
+    case "FORM/DATALOADED":
+      return dataLoaded(state, action.payload);
+    case "FORM/SAVINGCHANGES":
+      return savingChanges(state, action.payload);
+    case "FORM/CHANGESSAVED":
+      return changesSaved(state, action.payload);
+    case "FORM/REMOVINGRECORD":
+      return removingRecord(state, action.payload);
+    case "FORM/RECORDREMOVED":
+      return recordRemoved(state, action.payload);
+    case "FORM/INVALIDFIELD":
+      return invalidField(state, action.payload);
+    case "FORM/CLEAREDITION":
+      return clearAllInvalidFields(state, action.payload);
+    case "FORM/CHANGEFIELD":
+      return clearInvalidField(state, action.payload);
+    case "FORM/SHOWHIDENAVBTN":
+      return showHideNavBtn(state, action.payload);
+    default:
+      return state;
+  }
+}
+function collapseGroup(state, { collapseId, collapsed }) {
+  const currentCollapsed = Object.assign({}, state.collapsedGroups);
+  if (collapsed) {
+    currentCollapsed[collapseId] = true;
+  }
+  else {
+    delete currentCollapsed[collapseId];
+  }
+  return Object.assign(Object.assign({}, state), { collapsedGroups: currentCollapsed });
+}
+function changeTab(state, formId, index) {
+  const currentTabIndex = Object.assign({}, state.currentTabIndex);
+  currentTabIndex[formId] = index;
+  return Object.assign(Object.assign({}, state), { currentTabIndex });
+}
+function navigate(state, { dataUnit, limit, backward }) {
+  const currentRecordIndex = Object.assign({}, state.currentRecordIndex);
+  const recIndex = currentRecordIndex[dataUnit] || 0;
+  return gotoIndex(state, dataUnit, backward ? Math.max(limit, recIndex - 1) : Math.min(limit, recIndex + 1));
+}
+function gotoIndex(state, dataUnit, index) {
+  const currentRecordIndex = Object.assign({}, state.currentRecordIndex);
+  currentRecordIndex[dataUnit] = index;
+  return Object.assign(Object.assign({}, state), { currentRecordIndex });
+}
+function insertRecord(state, { dataUnit, insertionIndex }) {
+  const currentRecordIndex = Object.assign({}, state.currentRecordIndex);
+  const newRecordIndex = Object.assign({}, state.newRecordIndex);
+  currentRecordIndex[dataUnit] = insertionIndex;
+  newRecordIndex[dataUnit] = (state.newRecordIndex[dataUnit] || 0) + 1;
+  return Object.assign(Object.assign({}, state), { currentRecordIndex,
+    newRecordIndex });
+}
+function changeFieldValue(state, { dataUnit, recordId, fieldName, value }) {
+  const changes = Object.assign({}, state.changes);
+  const dataUnitChanges = Object.assign({}, changes[dataUnit]);
+  const recordChanges = Object.assign({}, dataUnitChanges[recordId]);
+  recordChanges[fieldName] = value;
+  dataUnitChanges[recordId] = recordChanges;
+  changes[dataUnit] = dataUnitChanges;
+  const invalidFields = Object.assign({}, state.invalidFields);
+  const dataUnitInvalidRecords = Object.assign({}, invalidFields[dataUnit]);
+  const errorMessages = Object.assign({}, dataUnitInvalidRecords[recordId]);
+  delete errorMessages[fieldName];
+  dataUnitInvalidRecords[recordId] = errorMessages;
+  invalidFields[dataUnit] = dataUnitInvalidRecords;
+  return Object.assign(Object.assign({}, state), { changes,
+    invalidFields, invalidFieldSelected: undefined });
+}
+function clearEdition(state, { dataUnit, recordsLimit }) {
+  const changes = Object.assign({}, state.changes);
+  const newRecordIndex = Object.assign({}, state.newRecordIndex);
+  const currentRecordIndex = Object.assign({}, state.currentRecordIndex);
+  delete changes[dataUnit];
+  delete newRecordIndex[dataUnit];
+  const recIndex = currentRecordIndex[dataUnit] || 0;
+  currentRecordIndex[dataUnit] = Math.min(recordsLimit, recIndex);
+  return Object.assign(Object.assign({}, state), { changes,
+    newRecordIndex,
+    currentRecordIndex });
+}
+function navigateToInvalid(state, payload) {
+  let newState = Object.assign({}, state);
+  if (newState.invalidFieldSelected === undefined) {
+    newState.invalidFieldSelected = true;
+    newState = gotoIndex(newState, payload.dataUnit, payload.recordIndex);
+    newState = changeTab(newState, payload.tabController, payload.tabIndex);
+  }
+  return newState;
+}
+function dataLoading(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  dataLoading[dataUnit] = true;
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function dataLoaded(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  delete dataLoading[dataUnit];
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function savingChanges(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  dataLoading[dataUnit] = true;
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function changesSaved(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  delete dataLoading[dataUnit];
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function removingRecord(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  dataLoading[dataUnit] = true;
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function recordRemoved(state, { dataUnit }) {
+  const dataLoading = Object.assign({}, state.dataLoading);
+  delete dataLoading[dataUnit];
+  return Object.assign(Object.assign({}, state), { dataLoading });
+}
+function invalidField(state, { dataUnit, recordId, fieldName, errorMessage }) {
+  const invalidFields = Object.assign({}, state.invalidFields);
+  const dataUnitInvalidRecords = Object.assign({}, invalidFields[dataUnit]);
+  const errorMessages = Object.assign({}, dataUnitInvalidRecords[recordId]);
+  errorMessages[fieldName] = errorMessage;
+  dataUnitInvalidRecords[recordId] = errorMessages;
+  invalidFields[dataUnit] = dataUnitInvalidRecords;
+  return Object.assign(Object.assign({}, state), { invalidFields });
+}
+function clearAllInvalidFields(state, { dataUnit }) {
+  const invalidFields = Object.assign({}, state.invalidFields);
+  delete invalidFields[dataUnit];
+  return Object.assign(Object.assign({}, state), { invalidFields });
+}
+function clearInvalidField(state, { dataUnit, recordId, fieldName }) {
+  const invalidFields = Object.assign({}, state.invalidFields);
+  const dataUnitInvalidRecords = Object.assign({}, invalidFields[dataUnit]);
+  const errorMessages = Object.assign({}, dataUnitInvalidRecords[recordId]);
+  delete errorMessages[fieldName];
+  dataUnitInvalidRecords[recordId] = errorMessages;
+  invalidFields[dataUnit] = dataUnitInvalidRecords;
+  return Object.assign(Object.assign({}, state), { invalidFields });
+}
+function showHideNavBtn(state, { buttonName, status }) {
+  const visibleButtons = Object.assign({}, state.visibleButtons);
+  visibleButtons[buttonName] = status;
+  return Object.assign(Object.assign({}, state), { visibleButtons });
+}
+
+function removeHandler(dataUnit) {
+  ApplicationUtils.ApplicationUtils.confirm("Exclusão de registro", "Tem certeza que deseja Remover?", null, true).then(ok => {
+    if (ok) {
+      dataUnit.remove();
+    }
+  });
+}
+function saveHandler(dataUnit) {
+  setTimeout(() => {
+    //Esse debouncing é necessário quando o usuário clica no botão de salvar 
+    //sem ter tirado o foco o último campo alterado.
+    dataUnit.save();
+  }, 50);
+}
+const NavigationBar = ({ dataUnit: du, buttonProps, enabled }) => {
+  if (buttonProps.previousVisible
+    || buttonProps.nextVisible
+    || buttonProps.addVisible
+    || buttonProps.removeVisible
+    || buttonProps.saveVisible
+    || buttonProps.cancelVisible
+    || buttonProps.reloadVisible) {
+    return index$1.h("div", { class: "col col--sd-12 align--right" },
+      buttonProps.previousVisible ? index$1.h("ez-button", { key: du.name + "_previous", title: "Registro anterior", mode: "icon", enabled: enabled && du.hasPrevious(), onClick: () => du.previous(), image: "/themes/default/images/icons/actions-sprite.svg#previous-circle-inverted", class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.nextVisible ? index$1.h("ez-button", { key: du.name + "_next", title: "Pr\u00F3ximo registro", mode: "icon", enabled: enabled && du.hasNext(), onClick: () => du.next(), image: "/themes/default/images/icons/actions-sprite.svg#next-circle-inverted", class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.removeVisible ? index$1.h("ez-button", { key: du.name + "_remove", label: "Remover", enabled: enabled && du.hasCurrentRecord(), onClick: () => removeHandler(du), image: "/themes/default/images/icons/actions-sprite.svg#minus-circle-inverted", class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.addVisible ? index$1.h("ez-button", { key: du.name + "_add", label: "Adicionar", enabled: enabled, onClick: () => du.insert(), class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.reloadVisible ? index$1.h("ez-button", { key: du.name + "_reload", title: "Recarregar", enabled: enabled, mode: "icon", onClick: () => du.load(), image: "/themes/default/images/icons/actions-sprite.svg#rotate", class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.cancelVisible ? index$1.h("ez-button", { key: du.name + "_cancel", label: "Cancelar", enabled: enabled && du.hasChanges(), onClick: () => du.cancel(), class: "button--secondary margin-right--medium" }) : null,
+      buttonProps.saveVisible ? index$1.h("ez-button", { key: du.name + "_save", label: "Salvar", enabled: enabled && du.hasChanges(), onClick: () => saveHandler(du), class: "button--primary margin-right--medium" }) : null);
+  }
+  else {
+    return null;
+  }
+};
+
+function scrollToView(forceScroll, elem) {
+  if (forceScroll) {
+    window.requestAnimationFrame(() => elem.scrollIntoView());
+  }
+}
+const Field = ({ dataUnit, field, forceScroll, enabled }) => {
+  const { name, form } = field;
+  const { label, userInterface, properties, required, dependencies, readOnly } = dataUnit.getFieldMetadata(name);
+  const value = dataUnit.getValue(name) || null;
+  const loadingData = dataUnit.isLoading();
+  const formattedLabel = required ? `* ${label} (obrigatório)` : label;
+  const errorMessage = dataUnit.getErrorMessage(name);
+  const key = `${dataUnit.name}-${name}`;
+  const isEnabled = enabled && !readOnly;
+  const changeFieldHandler = (newValue) => {
+    dataUnit.changeValue(name, newValue);
+  };
+  switch (userInterface) {
+    case "LONGTEXT":
+      return index$1.h("div", { class: "col col--sd-12 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-text-area", { value: value || "", label: formattedLabel, onEzChange: evt => changeFieldHandler(evt.target["value"]), errorMessage: errorMessage, ref: elem => scrollToView(forceScroll, elem), key: key, enabled: isEnabled }));
+    case "CHECKBOX":
+    case "SWITCH":
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small align--middle padding-bottom--large" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-check", { value: value, label: label, enabled: isEnabled, mode: userInterface === "CHECKBOX" ? "regular" : "switch", onEzChange: (event) => changeFieldHandler(event.target["value"]), ref: elem => scrollToView(forceScroll, elem), key: key }));
+    case "OPTIONSELECTOR":
+      const optsObj = properties ? JSON.parse(getProp(properties, "options")) : {};
+      const normalized = Object.keys(optsObj).map(key => { return { value: key, label: optsObj[key] }; });
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-combo-box", { value: value, label: formattedLabel, enabled: isEnabled, onEzChange: (event) => changeFieldHandler(event.target["value"]), errorMessage: errorMessage, ref: elem => scrollToView(forceScroll, elem), key: key, options: normalized }));
+    case "SEARCH":
+      const context = {
+        __MAIN_FORM: form,
+        __DATA_UNIT: dataUnit.name,
+        __FIELD_NAME: name
+      };
+      properties.forEach(({ name, value }) => {
+        context[name] = value;
+      });
+      let criteriaList = [];
+      dependencies === null || dependencies === void 0 ? void 0 : dependencies.forEach(dependency => {
+        var _a;
+        if (dependency.type === DataUnit.DependencyType.SEARCHING) {
+          if (((_a = dependency.masterFields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            let criteria = {
+              expression: dependency.expression,
+              paramNames: [...dependency.masterFields],
+              paramResolver: name => dataUnit.getValue(name)
+            };
+            criteriaList.push(criteria);
+          }
+        }
+      });
+      if (criteriaList.length > 0) {
+        context["CRITERIA"] = criteriaList;
+      }
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-search", { value: value, label: formattedLabel, enabled: isEnabled, onEzChange: (event) => changeFieldHandler(event.target["value"]), errorMessage: errorMessage, optionLoader: (argument) => {
+            if (form) {
+              return form.loadSearch(argument, context);
+            }
+          }, ref: elem => scrollToView(forceScroll, elem), key: key }));
+    case "FILE":
+      const target = getProp(properties, "URL");
+      const strHeaders = getProp(properties, "HEADERS");
+      const headers = strHeaders ? JSON.parse(strHeaders) : {};
+      const maxfiles = Number(getProp(properties, "maxfiles") || 0);
+      return (index$1.h("div", { class: "col col--sd-12 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-upload", { value: value, label: formattedLabel, enabled: isEnabled, onEzChange: (event) => changeFieldHandler(event.detail), urlUpload: target, requestHeaders: headers, maxFiles: maxfiles })));
+    case "DATE":
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-date-input", { value: !value ? null : DateUtils.DateUtils.clearTime(value), label: formattedLabel, enabled: isEnabled, onEzChange: (event) => changeFieldHandler(event.target["value"]), errorMessage: errorMessage, ref: elem => scrollToView(forceScroll, elem), key: key }));
+    case "DECIMALNUMBER":
+    case "INTEGERNUMBER":
+      let precision = 0;
+      let prettyPrecision = 0;
+      if (userInterface === "DECIMALNUMBER") {
+        precision = Number(getProp(properties, "precision") || 2);
+        prettyPrecision = Number(getProp(properties, "prettyprecision") || precision);
+      }
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-numeric-input", { value: !value ? null : value, label: formattedLabel, enabled: isEnabled, onEzChange: (event) => changeFieldHandler(event.target["value"]), errorMessage: errorMessage, precision: precision, prettyprecision: prettyPrecision, ref: elem => scrollToView(forceScroll, elem), key: key }));
+    //IMAGE, DATETIME, ELAPSEDTIME, PASSWORD, MASKEDTEXT, HTML
+    default:
+      return index$1.h("div", { class: "col col--sd-12 col--tb-3 padding--small" }, loadingData ? index$1.h("place-holder", null) :
+        index$1.h("ez-text-input", { value: value, label: formattedLabel, enabled: isEnabled, loading: loadingData, onInput: (event) => changeFieldHandler(event.target["value"]), errorMessage: errorMessage, ref: elem => scrollToView(forceScroll, elem), key: key }));
+  }
+};
+function getProp(properties, name) {
+  var _a;
+  return properties ? (_a = properties.find(prop => prop.name === name)) === null || _a === void 0 ? void 0 : _a.value : null;
+}
+
+const FieldSet = ({ store, formName, source, dataUnit, enabled }) => {
+  const { label, fields } = source;
+  const fieldSetName = formName + label;
+  let isCollapsed = DataUnit.selectIsCollapsedFieldSet(store.getState(), formName + label);
+  let fieldToScroll;
+  source.fields.forEach((field) => {
+    if (fieldToScroll === undefined) {
+      const fieldError = dataUnit.getErrorMessage(field.name);
+      if (fieldError !== undefined && fieldError !== null && fieldError !== "") {
+        fieldToScroll = field.name;
+      }
+    }
+  });
+  if (fieldToScroll) {
+    isCollapsed = false;
+  }
+  return index$1.h("div", { class: "col col--sd-12 padding--small" },
+    index$1.h("div", { class: "row margin-top--large" },
+      index$1.h("div", { class: "col col--sd-12 align--middle padding-horizontal--medium" },
+        index$1.h("ez-collapsible-box", { value: isCollapsed, label: label, onEzChange: () => store.dispatch(DataUnit.collapseExpandGroup(fieldSetName, !isCollapsed)) }),
+        isCollapsed ? null :
+          index$1.h("div", { class: "col col--sd-12" }, fields.map(field => index$1.h(Field, { enabled: enabled, field: field, dataUnit: dataUnit, forceScroll: fieldToScroll === field.name }))))));
+};
+
+function buildFormItem(source, formName, store, dataUnit, enabled) {
+  if ("fields" in source) {
+    return index$1.h(FieldSet, { enabled: enabled, source: source, store: store, formName: formName, dataUnit: dataUnit });
+  }
+  const fieldName = source.name;
+  const errorMsg = dataUnit.getErrorMessage(fieldName);
+  const forceScroll = errorMsg === undefined || errorMsg === null || errorMsg === "" ? false : true;
+  return index$1.h(Field, { enabled: enabled, field: source, dataUnit: dataUnit, forceScroll: forceScroll });
+}
+const FormSheet = ({ store, parentName, source, parentDataUnit, dataUnitBuilder, enabled }) => {
+  const selectedTab = DataUnit.selectCurrentTab(store.getState(), parentName);
+  const tabs = source.length > 1 ? source.map(form => index$1.h("ez-tab", { label: form.label, tabKey: form.name })) : null;
+  const { subForms, items, name } = source[selectedTab];
+  const dataUnit = dataUnitBuilder(source[selectedTab].dataUnit, parentDataUnit);
+  source[selectedTab].dataUnit = dataUnit;
+  const hasSubForms = subForms && subForms.length > 0;
+  const changeTabHandler = (index) => {
+    store.dispatch(DataUnit.changeTab(parentName, index));
+  };
+  //todos os campos e subformulários precisam estar ligados a um DU
+  const currentDU = dataUnit || parentDataUnit;
+  let buttons = DataUnit.selectVisibleButtons(store.getState());
+  if (currentDU.cardinality === "1") {
+    buttons.addVisible = false;
+    buttons.removeVisible = false;
+    buttons.nextVisible = false;
+    buttons.previousVisible = false;
+  }
+  return index$1.h("div", { class: "form-sheet" },
+    tabs ? index$1.h("ez-tabselector", { selectedIndex: selectedTab, selectedTab: name, onEzChange: (evt) => changeTabHandler(evt.target.selectedindex) }, tabs) : null,
+    dataUnit ? index$1.h(NavigationBar, { enabled: enabled, dataUnit: dataUnit, buttonProps: buttons }) : null,
+    index$1.h("div", { class: "tab__container" },
+      items ? items.map(item => buildFormItem(item, name, store, currentDU, enabled)) : null,
+      hasSubForms ? index$1.h(FormSheet, { enabled: enabled, store: store, source: subForms, parentName: name, parentDataUnit: currentDU, dataUnitBuilder: dataUnitBuilder }) : null));
+};
+
+const ezFormCss = "ez-form{display:flex;flex-direction:column;width:100%}.form-sheet{display:flex;width:100%;flex-wrap:wrap;position:relative}.tab__container{display:flex;width:100%;flex-wrap:wrap;position:relative}";
+
+let EzForm = class {
+  constructor(hostRef) {
+    index$1.registerInstance(this, hostRef);
+    this.enabled = true;
+    this.loading = false;
+    this._dataUnits = new Map();
+    this._duSources = new Map();
+    this._tabPositionByField = new Map();
+    this._duToLoad = [];
+  }
+  cleanPreparedMetadata() {
+    this._preparedMetadata = undefined;
+  }
+  async validate() {
+    const duSourcesNames = Array.from(this._duSources.keys());
+    for (let i = 0; i < this._duSources.size; i++) {
+      const duName = duSourcesNames[i];
+      let du = this._dataUnits.get(duName);
+      if (du === undefined) {
+        const source = this._duSources.get(duName);
+        du = this.buildDataUnit(source, source.parentDUName);
+      }
+      if (!du.validateRecords()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async getChanges() {
+    let allChanges = [];
+    const dataUnits = Array.from(this._dataUnits.values());
+    for (let i = 0; i < this._dataUnits.size; i++) {
+      const du = dataUnits[i];
+      //Só devemos buscar as alterações de DU raiz, pois os sub DUs serão enviados junto.
+      if (!du.parentDU) {
+        const duChanges = du.getChangesToSave();
+        if (duChanges) {
+          allChanges = allChanges.concat(duChanges);
+        }
+      }
+    }
+    return allChanges;
+  }
+  async changeFieldValue(dataUnit, fieldName, value) {
+    const du = this._dataUnits.get(dataUnit);
+    if (du) {
+      du.changeValue(fieldName, value);
+    }
+  }
+  validateRecords(dataUnit, records, triggedBy) {
+    const result = { isValid: true, message: "" };
+    if (this.ignoreSaveValidation && triggedBy === "SAVE") {
+      return result;
+    }
+    const validateField = (field) => {
+      if (field.readOnly) {
+        return false;
+      }
+      if (field.userInterface === "SWITCH" || field.userInterface === "CHECKBOX") {
+        return false;
+      }
+      return true;
+    };
+    const recordValidator = record => {
+      dataUnit.requiredFields.forEach(field => {
+        if (validateField(field)) {
+          const recordIndex = record["record__index"];
+          const fieldName = field.name;
+          const fieldValue = record[fieldName];
+          if (fieldValue === null || fieldValue === undefined || fieldValue === "") {
+            const tabPosition = this._tabPositionByField.get(dataUnit.name + field.name);
+            this._store.dispatch(DataUnit.invalidField(tabPosition.tabName, tabPosition.index, dataUnit.name, recordIndex, record.record__id, field.name, "Essa informação é obrigatória"));
+            result.isValid = false;
+            result.message = "Há pelo menos um campo obrigatório não preenchido.";
+          }
+        }
+      });
+    };
+    if (dataUnit.records.length === 0) {
+      recordValidator({});
+    }
+    else {
+      let validatedRecords = {};
+      records.forEach(r => {
+        recordValidator(r);
+        validatedRecords[r.record__id] = true;
+      });
+      dataUnit.records.forEach(r => {
+        if (!validatedRecords[r.record__id]) {
+          recordValidator(r);
+        }
+      });
+    }
+    return result;
+  }
+  loadMDFromExecutor(callBack) {
+    const loadMetadataFunction = this.parseExecutor(this.metadataExecutor);
+    if (loadMetadataFunction) {
+      const result = loadMetadataFunction();
+      if (result) {
+        if (result instanceof Promise) {
+          result.then(md => {
+            callBack(md);
+          });
+        }
+        else {
+          callBack(result);
+        }
+      }
+    }
+  }
+  loadMDFromElement(callBack) {
+    const metadata = [];
+    Array.from(this._host.children).forEach(elem => {
+      if (elem.tagName === "FORM-METADATA") {
+        const formMetadata = elem;
+        metadata.push(formMetadata.metadata);
+      }
+    });
+    callBack(metadata.length > 0 ? metadata : null);
+  }
+  updateMetadata(metadata) {
+    if (metadata) {
+      const processFields = (duName, form, tabController, tabIndex) => {
+        var _a;
+        form.items.forEach(item => {
+          if ("fields" in item) {
+            const fSet = item;
+            fSet.fields.forEach(f => {
+              f.form = this;
+              this._tabPositionByField.set(duName + f.name, { tabName: tabController, index: tabIndex });
+            });
+          }
+          else {
+            const f = item;
+            f.form = this;
+            this._tabPositionByField.set(duName + f.name, { tabName: tabController, index: tabIndex });
+          }
+        });
+        (_a = form.subForms) === null || _a === void 0 ? void 0 : _a.forEach((subForm, index) => {
+          const subDu = subForm.dataUnit;
+          if (subDu) {
+            this._duSources.set(subDu.name, subDu);
+            subDu.parentDUName = duName;
+          }
+          processFields(subDu ? subDu.name : duName, subForm, form.name, index);
+        });
+      };
+      this._preparedMetadata = metadata.map((form, index) => {
+        const du = form.dataUnit;
+        if (form.autoLoad) {
+          this._duToLoad.push(du);
+        }
+        this.decorateDU(du);
+        const duName = du.name;
+        this._duSources.set(duName, du);
+        processFields(duName, form, "__MAIN__FORM__", index);
+        return form;
+      });
+      this._store.dispatch(DataUnit.formLoad());
+    }
+  }
+  parseExecutor(executor) {
+    if (executor) {
+      return executor instanceof Function ? executor : eval(executor);
+    }
+    return null;
+  }
+  componentWillRender() {
+    if (this._store === undefined) {
+      const rootReducer = combineReducers({
+        "hist": undoable(formReducer),
+        "nonhist": formNonHistoricReducer
+      });
+      this._store = createStore(rootReducer, applyMiddleware(thunk));
+      this._store.subscribe(() => { index$1.forceUpdate(this); });
+      if (this.slaveMode) {
+        this._store.dispatch(DataUnit.showHideNavigationButtons("saveVisible", false));
+        this._store.dispatch(DataUnit.showHideNavigationButtons("cancelVisible", false));
+        this._store.dispatch(DataUnit.showHideNavigationButtons("reloadVisible", false));
+      }
+    }
+    if (this._preparedMetadata === undefined) {
+      if (this.metadata) {
+        this.updateMetadata(this.metadata);
+      }
+      else {
+        this.loadMDFromElement((md) => this.updateMetadata(md));
+        if (!this._preparedMetadata) {
+          this.loadMDFromExecutor((md) => this.updateMetadata(md));
+        }
+      }
+    }
+  }
+  componentDidRender() {
+    this._duToLoad.forEach(du => du.load());
+    this._duToLoad = [];
+  }
+  loadSearch(argument, context) {
+    const fieldSearchExecutor = this.parseExecutor(this.fieldSearchExecutor);
+    if (fieldSearchExecutor) {
+      return fieldSearchExecutor(argument, context);
+    }
+    else {
+      return [{ value: 0, label: "Sem resultados" }];
+    }
+  }
+  buildDataUnit(dataUnit, parentDataUnit) {
+    if (dataUnit) {
+      const { name, unitLabel, records, cardinality, fields } = dataUnit;
+      if (!(dataUnit instanceof DataUnit.DataUnit)) {
+        let parent;
+        if (parentDataUnit instanceof DataUnit.DataUnit) {
+          parent = parentDataUnit;
+        }
+        else {
+          parent = this._dataUnits.get(parentDataUnit);
+        }
+        dataUnit = new DataUnit.DataUnit(name, unitLabel, cardinality, parent);
+        dataUnit.fields = fields;
+        this._dataUnits.set(dataUnit.name, dataUnit);
+        if (records) {
+          dataUnit.records = records;
+        }
+      }
+      this.decorateDU(dataUnit);
+    }
+    return dataUnit;
+  }
+  decorateDU(dataUnit) {
+    dataUnit.store = this._store;
+    dataUnit.loadExecutor = this.parseExecutor(this.loadExecutor);
+    dataUnit.saveExecutor = this.parseExecutor(this.saveExecutor);
+    dataUnit.removeExecutor = this.parseExecutor(this.removeExecutor);
+    dataUnit.recordsValidator = this;
+  }
+  render() {
+    if (this.loading) {
+      return index$1.h("place-holder", null);
+    }
+    else {
+      return this._preparedMetadata ? index$1.h(FormSheet, { enabled: this.enabled, store: this._store, source: this._preparedMetadata, parentName: "__MAIN__FORM__", dataUnitBuilder: (du, parentDataUnit) => this.buildDataUnit(du, parentDataUnit) }) : null;
+    }
+  }
+  static get assetsDirs() { return ["assets"]; }
+  get _host() { return index$1.getElement(this); }
+  static get watchers() { return {
+    "metadata": ["cleanPreparedMetadata"]
+  }; }
+};
+EzForm.style = ezFormCss;
+
+exports.ez_form = EzForm;