@sankhyalabs/sankhyablocks 1.1.27 → 1.3.0

package/dist/components/ez-form2.js

@@ -1,807 +0,0 @@
-import { h, proxyCustomElement, HTMLElement, forceUpdate, Host } from '@stencil/core/internal/client';
-import { UserInterface, ApplicationContext, Action, DataUnitAction, DataUnit } from '@sankhyalabs/core';
-import { A as ApplicationUtils } from './ApplicationUtils.js';
-import { d as defineCustomElement$1 } from './ez-tabselector2.js';
-
-const buildTextArea = ({ name, label, readOnly }) => {
-  return (h("div", { class: "col col--sd-12 padding-horizontal--small", key: name },
-    h("ez-text-area", { enabled: !readOnly, label: label, "data-field-name": name })));
-};
-
-const buildTextInput = ({ name, label }) => {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-text-input", { label: label, "data-field-name": name, key: name })));
-};
-
-const buildSwitch = (fieldConfig) => {
-  return buildField$1(fieldConfig.name, fieldConfig.label, fieldConfig.readOnly, true);
-};
-const buildCheckBox = (fieldConfig) => {
-  return buildField$1(fieldConfig.name, fieldConfig.label, fieldConfig.readOnly, false);
-};
-function buildField$1(fieldName, fieldLabel, readOnly, switchMode = false) {
-  return (h("div", { class: "col col--sd-12 col--tb-3 align--middle padding-horizontal--small padding-bottom--large" },
-    h("ez-check", { enabled: !readOnly, label: fieldLabel, mode: switchMode ? "switch" : "regular", "data-field-name": fieldName, key: fieldName })));
-}
-
-const buildComboBox = ({ name, label, readOnly }, properties) => {
-  const prop = properties === null || properties === void 0 ? void 0 : properties.options;
-  let options;
-  if (typeof prop === "string") {
-    const parsed = JSON.parse(prop);
-    options = Object.keys(parsed).map(key => { return { value: key, label: parsed[key] }; });
-  }
-  else {
-    options = prop;
-  }
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-combo-box", { enabled: !readOnly, label: label, "data-field-name": name, key: name, options: options })));
-};
-
-const buildSearch = ({ name, label, readOnly }) => {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-search", { enabled: !readOnly, label: label, "data-field-name": name, key: name })));
-};
-
-const buildFile = ({ name, label, readOnly }) => {
-  return (h("div", { class: "col col--sd-12 padding-horizontal--small" },
-    h("ez-upload", { enabled: !readOnly, label: label, urlUpload: "", requestHeaders: "", maxFiles: 10, "data-field-name": name, key: name })));
-};
-
-const buildDate = ({ name, label, readOnly }) => {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-date-input", { enabled: !readOnly, label: label, "data-field-name": name, key: name })));
-};
-const buildTime = ({ name, label }) => {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-time-input", { label: label, "data-field-name": name, key: name })));
-};
-const buildTimeDate = ({ name, label }) => {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-date-time-input", { label: label, "data-field-name": name, key: name })));
-};
-
-const buildDecimal = ({ name, label, readOnly }, properties) => {
-  const precision = Number((properties === null || properties === void 0 ? void 0 : properties.precision) || 2);
-  const prettyPrecision = Number((properties === null || properties === void 0 ? void 0 : properties.prettyPrecision) || precision);
-  return buildNumeric(name, label, readOnly, precision, prettyPrecision);
-};
-const buildInteger = ({ name, label, readOnly }) => {
-  return buildNumeric(name, label, readOnly, 0, 0);
-};
-function buildNumeric(fieldName, fieldLabel, readOnly, precision, prettyPrecision) {
-  return (h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
-    h("ez-number-input", { enabled: !readOnly, label: fieldLabel, precision: precision, prettyPrecision: prettyPrecision, "data-field-name": fieldName, key: fieldName })));
-}
-
-const uiBuilders = new Map();
-uiBuilders.set(UserInterface.LONGTEXT, buildTextArea);
-uiBuilders.set(UserInterface.CHECKBOX, buildCheckBox);
-uiBuilders.set(UserInterface.SWITCH, buildSwitch);
-uiBuilders.set(UserInterface.OPTIONSELECTOR, buildComboBox);
-uiBuilders.set(UserInterface.SEARCH, buildSearch);
-uiBuilders.set(UserInterface.FILE, buildFile);
-uiBuilders.set(UserInterface.DATE, buildDate);
-uiBuilders.set(UserInterface.TIME, buildTime);
-uiBuilders.set(UserInterface.DATETIME, buildTimeDate);
-uiBuilders.set(UserInterface.DECIMALNUMBER, buildDecimal);
-uiBuilders.set(UserInterface.INTEGERNUMBER, buildInteger);
-const buildField = (field) => {
-  const descriptor = field.descriptor;
-  const config = Object.assign({}, field.config);
-  let builder;
-  let props;
-  if (descriptor) {
-    if (!config.label) {
-      config.label = descriptor.label;
-    }
-    if (!config.name) {
-      config.name = descriptor.name;
-    }
-    if (config.required === undefined) {
-      config.required = descriptor.required;
-    }
-    if (config.readOnly === undefined) {
-      config.readOnly = descriptor.readOnly;
-    }
-    props = descriptor.properties;
-    builder = uiBuilders.get(descriptor.userInterface);
-  }
-  if (config.required) {
-    config.label = `* ${config.label} (obrigatório)`;
-  }
-  if (!builder) {
-    builder = buildTextInput;
-  }
-  return builder(config, props);
-};
-
-const FormItem = ({ source }) => {
-  if ("items" in source) {
-    const fieldSet = source;
-    return h("ez-collapsible-box", { label: source.label }, fieldSet.items.map(fi => buildField(fi)));
-  }
-  else {
-    return buildField(source);
-  }
-};
-
-const FormSheet = ({ store, source }) => {
-  return (h("div", { class: "box__container" },
-    h("div", { class: "row padding-vertical--small" }, source.items.map(item => h(FormItem, { store: store, source: item })))));
-};
-
-class FormMetadata {
-  constructor() {
-    this._sheets = new Map();
-    this._requiredFields = [];
-    this._cleanOnCopyFields = [];
-  }
-  getSheet(name) {
-    return this._sheets.get(name);
-  }
-  getAllSheets() {
-    return this._sheets;
-  }
-  addSheet(sheet) {
-    this._sheets.set(sheet.name, sheet);
-    this._requiredFields = this._requiredFields.concat(sheet.requiredFields);
-    this._cleanOnCopyFields = this._cleanOnCopyFields.concat(sheet.cleanOnCopyFields);
-  }
-  getRequiredFields() {
-    return this._requiredFields;
-  }
-  getCleanOnCopyFields() {
-    return this._cleanOnCopyFields;
-  }
-}
-const buildFromDataUnit = (dataUnit) => {
-  var _a;
-  const unitMD = dataUnit.metadata;
-  const metadata = new FormMetadata();
-  if (unitMD) {
-    const visibleFields = (_a = unitMD.fields) === null || _a === void 0 ? void 0 : _a.filter(descriptor => descriptor.visible !== false);
-    metadata.addSheet({
-      label: unitMD.label,
-      name: unitMD.name,
-      items: visibleFields.map(descriptor => { return { descriptor }; }),
-      requiredFields: visibleFields
-        .filter(descriptor => descriptor.required)
-        .map(descriptor => descriptor.name),
-      cleanOnCopyFields: visibleFields
-        .filter(descriptor => { var _a; return (_a = descriptor.properties) === null || _a === void 0 ? void 0 : _a.cleanOnCopy; })
-        .map(descriptor => descriptor.name)
-    });
-  }
-  return metadata;
-};
-function getTabConfig(tab, sheets) {
-  const tabConfig = (typeof tab === "string" ? Array.from(sheets.keys()).find(t => t.label === tab) : tab);
-  return tabConfig || { label: tab, visible: true };
-}
-const buildFromConfig = (fields, dataUnit) => {
-  const sheets = new Map();
-  const requiredFields = [];
-  const cleanOnCopyFields = [];
-  fields.forEach(config => {
-    var _a;
-    if (config.visible !== false) {
-      const tabConfig = getTabConfig(config.tab || "Geral", sheets);
-      const descriptor = dataUnit.getField(config.name);
-      if (descriptor && tabConfig.visible) {
-        if (!sheets.has(tabConfig)) {
-          sheets.set(tabConfig, new Map());
-        }
-        const tabItens = sheets.get(tabConfig);
-        const isRequired = config.required === undefined ? descriptor.required : config.required;
-        if (isRequired) {
-          requiredFields.push(config.name);
-        }
-        const clearOnCopy = config.cleanOnCopy === undefined ? (_a = descriptor.properties) === null || _a === void 0 ? void 0 : _a.cleanOnCopy : config.cleanOnCopy;
-        if (clearOnCopy) {
-          cleanOnCopyFields.push(config.name);
-        }
-        const fieldMD = { config, descriptor };
-        const group = config.group;
-        if (group) {
-          const key = `group::${group}`;
-          if (!tabItens.has(key)) {
-            tabItens.set(key, { label: group, items: [fieldMD] });
-          }
-          else {
-            tabItens.get(key).items.push(fieldMD);
-          }
-        }
-        else {
-          tabItens.set(config.name, fieldMD);
-        }
-      }
-    }
-  });
-  const metadata = new FormMetadata();
-  Array.from(sheets.entries())
-    .sort((a, b) => (a[0].order || 10000) - (b[0].order || 10000))
-    .forEach(([key, value]) => {
-    metadata.addSheet({
-      label: key.label,
-      name: key.label,
-      items: Array.from(value.values()),
-      requiredFields,
-      cleanOnCopyFields
-    });
-  });
-  return metadata;
-};
-
-/**
- * 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;
-}
-
-/**
- * @deprecated
- *
- * **We recommend using the `configureStore` method
- * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
- *
- * Redux Toolkit is our recommended approach for writing Redux logic today,
- * including store setup, reducers, data fetching, and more.
- *
- * **For more details, please read this Redux docs page:**
- * **https://redux.js.org/introduction/why-rtk-is-redux-today**
- *
- * `configureStore` from Redux Toolkit is an improved version of `createStore` that
- * simplifies setup and helps avoid common bugs.
- *
- * You should not be using the `redux` core package by itself today, except for learning purposes.
- * The `createStore` method from the core `redux` package will not be removed, but we encourage
- * all users to migrate to using Redux Toolkit for all Redux code.
- *
- * If you want to use `createStore` without this visual deprecation warning, use
- * the `legacy_createStore` import instead:
- *
- * `import { legacy_createStore as createStore} from 'redux'`
- *
- */
-
-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;
-}
-
-const inicialState = {};
-///////////////////////////////     REDUCERS     ///////////////////////////////
-function formReducer(state = inicialState, action) {
-  switch (action.type) {
-    case FormActions.METADATA_LOADED:
-      return Object.assign(Object.assign({}, state), { formMetadata: action.payload });
-    case FormActions.CHANGE_TAB:
-      return Object.assign(Object.assign({}, state), { currentSheet: action.payload });
-    default:
-      return state;
-  }
-}
-/////////////////////////////// ACTION CREATORS ///////////////////////////////
-function loadMetadata(formMetadata) {
-  return {
-    type: FormActions.METADATA_LOADED,
-    payload: formMetadata
-  };
-}
-function changeTab(currentSheet) {
-  return {
-    type: FormActions.CHANGE_TAB,
-    payload: currentSheet.tabKey
-  };
-}
-///////////////////////////////    SELECTORS    ///////////////////////////////
-function selectFormMetadata(state) {
-  return state.formMetadata;
-}
-function selectCurrentSheet(state) {
-  return state.currentSheet ? state.formMetadata.getSheet(state.currentSheet) : Array.from(state.formMetadata.getAllSheets().values())[0];
-}
-///////////////////////////////      TYPES      ///////////////////////////////
-var FormActions;
-(function (FormActions) {
-  FormActions["METADATA_LOADED"] = "FORM/METADATA_LOADED";
-  FormActions["CHANGE_TAB"] = "FORM/CHANGE_TAB";
-})(FormActions || (FormActions = {}));
-
-class DataBinder {
-  constructor(dataUnit) {
-    this._fields = new Map();
-    this._dataUnit = dataUnit;
-    this._dataUnit.subscribe(_action => {
-      var _a;
-      (_a = this._fields) === null || _a === void 0 ? void 0 : _a.forEach(field => {
-        this.updateValue(field.fieldName, field.field);
-      });
-    });
-  }
-  bind(fields) {
-    fields.forEach(fieldElement => {
-      const fieldName = fieldElement.dataset.fieldName;
-      this.updateBind(fieldName, fieldElement);
-      this.updateValue(fieldName, fieldElement);
-    });
-  }
-  updateValue(fieldName, field) {
-    field["value"] = this._dataUnit.getFieldValue(fieldName);
-  }
-  updateBind(fieldName, field) {
-    const oldBind = this._fields.get(fieldName);
-    if (oldBind) {
-      oldBind.destroy();
-    }
-    this._fields.set(fieldName, Bind.create(fieldName, field, (fieldName, newValue) => this.setFieldValue(fieldName, newValue)));
-    this.bindSearchOptionsLoader(fieldName, field);
-  }
-  setFieldValue(fieldName, newValue) {
-    if (this._dataUnit.records.length === 0) {
-      this._dataUnit.addRecord();
-    }
-    this._dataUnit.setFieldValue(fieldName, newValue);
-  }
-  bindSearchOptionsLoader(fieldName, field) {
-    if (field.nodeName === "EZ-SEARCH" && field["optionLoader"] === undefined) {
-      const loader = ApplicationContext.getContextValue("__EZUI__SEARCH__OPTION__LOADER__");
-      if (loader) {
-        field["optionLoader"] = (arg) => {
-          return loader(arg, fieldName, this._dataUnit);
-        };
-      }
-    }
-  }
-}
-class Bind {
-  destroy() {
-    this.field.removeEventListener(this.eventName, this.eventListener);
-  }
-  static create(fieldName, field, callback) {
-    const b = new Bind();
-    b.fieldName = fieldName;
-    b.field = field;
-    //FIXME: Verificar se o field é um EzField
-    b.eventListener = (evt) => { callback(fieldName, evt.detail); };
-    b.eventName = "ezChange";
-    b.field.addEventListener(b.eventName, b.eventListener);
-    return b;
-  }
-}
-
-const ezFormCss = "ez-form{display:flex;flex-direction:column;width:100%}";
-
-const EzForm = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
-  constructor() {
-    super();
-    this.__registerHost();
-  }
-  submit() {
-    return Promise.resolve();
-  }
-  cancel() {
-    return Promise.resolve();
-  }
-  validate() {
-    return new Promise((accept, reject) => {
-      const metadata = selectFormMetadata(this._store.getState());
-      const requiredFields = this._staticFields
-        .filter(f => f.dataset.required)
-        .map(f => f.dataset.fieldName)
-        .concat(metadata.getRequiredFields());
-      const records = this.dataUnit.records;
-      for (let i = 0; i < records.length; i++) {
-        if (!this.validateRequired(requiredFields, records[i])) {
-          reject();
-          break;
-        }
-      }
-      accept();
-    });
-  }
-  configChanged() {
-    this.processMetadata();
-  }
-  validateRequired(requiredFields, record) {
-    const invalidFields = [];
-    requiredFields.forEach(field => {
-      const value = record[field];
-      const fieldElem = this._element.querySelector(`[data-field-name=${field}]`);
-      if (value === null || value === undefined || value === "") {
-        invalidFields.push(field);
-        fieldElem["errorMessage"] = "Essa informação é obrigatória";
-      }
-      else {
-        fieldElem["errorMessage"] = "";
-      }
-    });
-    const isValid = invalidFields.length === 0;
-    if (!isValid) {
-      ApplicationUtils.info("Há pelo menos um campo obrigatório não preenchido.");
-    }
-    return isValid;
-  }
-  getDynamicContent() {
-    var _a;
-    const formMD = selectFormMetadata(this._store.getState());
-    if (!formMD)
-      return null;
-    const currentSheet = selectCurrentSheet((_a = this._store) === null || _a === void 0 ? void 0 : _a.getState());
-    if (!currentSheet) {
-      return null;
-    }
-    const allSheets = Array.from(formMD.getAllSheets().values());
-    const result = [];
-    if (allSheets.length > 1) {
-      result.push(h("ez-tabselector", { onEzChange: (evt) => this._store.dispatch(changeTab(evt.detail)), selectedTab: currentSheet.name }, allSheets.map(s => h("ez-tab", { tabKey: s.name, label: s.label }))));
-    }
-    result.push(h(FormSheet, { store: this._store, source: currentSheet }));
-    return result;
-  }
-  processMetadata() {
-    if (!this.isStatic()) {
-      const metadata = this.config && this.config.length > 0 ? buildFromConfig(this.config, this.dataUnit) : buildFromDataUnit(this.dataUnit);
-      this._store.dispatch(loadMetadata(metadata));
-    }
-  }
-  isStatic() {
-    var _a;
-    return ((_a = this._staticFields) === null || _a === void 0 ? void 0 : _a.length) > 0;
-  }
-  interceptAction(action) {
-    if (action.type === Action.RECORDS_COPIED) {
-      const metadata = selectFormMetadata(this._store.getState());
-      const cleanFields = metadata.getCleanOnCopyFields();
-      if (cleanFields) {
-        const records = action.payload;
-        return new DataUnitAction(Action.RECORDS_COPIED, records.map(record => {
-          const newRecord = Object.assign({}, record);
-          cleanFields.forEach(fieldName => delete newRecord[fieldName]);
-          return newRecord;
-        }));
-      }
-    }
-    return action;
-  }
-  componentWillLoad() {
-    if (this.dataUnit === undefined) {
-      this.dataUnit = new DataUnit("ez-form");
-    }
-    this.dataUnit.addInterceptor(this);
-    this.dataUnit.subscribe(action => {
-      if (action.type === Action.METADATA_LOADED) {
-        this.processMetadata();
-      }
-    });
-    this._dataBinder = new DataBinder(this.dataUnit);
-    this._store = createStore(formReducer);
-    this._store.subscribe(() => forceUpdate(this));
-    this._staticFields = Array.from(this._element.querySelectorAll("[data-field-name]"));
-    this.processMetadata();
-  }
-  componentDidRender() {
-    this._dataBinder.bind(Array.from(this._element.querySelectorAll("[data-field-name]")));
-  }
-  render() {
-    return (h(Host, null, this.isStatic() ? null : this.getDynamicContent()));
-  }
-  get _element() { return this; }
-  static get watchers() { return {
-    "config": ["configChanged"]
-  }; }
-  static get style() { return ezFormCss; }
-}, [0, "ez-form", {
-    "dataUnit": [1040],
-    "config": [16],
-    "submit": [64],
-    "cancel": [64],
-    "validate": [64]
-  }]);
-function defineCustomElement() {
-  if (typeof customElements === "undefined") {
-    return;
-  }
-  const components = ["ez-form", "ez-tabselector"];
-  components.forEach(tagName => { switch (tagName) {
-    case "ez-form":
-      if (!customElements.get(tagName)) {
-        customElements.define(tagName, EzForm);
-      }
-      break;
-    case "ez-tabselector":
-      if (!customElements.get(tagName)) {
-        defineCustomElement$1();
-      }
-      break;
-  } });
-}
-
-export { EzForm as E, defineCustomElement as d };