@sankhyalabs/sankhyablocks 1.1.24 → 1.1.25

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

@@ -0,0 +1,463 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-682c98b2.js');
+const core = require('@sankhyalabs/core');
+const redux = require('redux');
+const ApplicationUtils = require('./ApplicationUtils-05b74ee9.js');
+
+const buildTextArea = ({ name, label, readOnly }) => {
+  return (index.h("div", { class: "col col--sd-12 padding-horizontal--small", key: name },
+    index.h("ez-text-area", { enabled: !readOnly, label: label, "data-field-name": name })));
+};
+
+const buildTextInput = ({ name, label }) => {
+  return (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.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 (index.h("div", { class: "col col--sd-12 col--tb-3 align--middle padding-horizontal--small padding-bottom--large" },
+    index.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 (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.h("ez-combo-box", { enabled: !readOnly, label: label, "data-field-name": name, key: name, options: options })));
+};
+
+const buildSearch = ({ name, label, readOnly }) => {
+  return (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.h("ez-search", { enabled: !readOnly, label: label, "data-field-name": name, key: name })));
+};
+
+const buildFile = ({ name, label, readOnly }) => {
+  return (index.h("div", { class: "col col--sd-12 padding-horizontal--small" },
+    index.h("ez-upload", { enabled: !readOnly, label: label, urlUpload: "", requestHeaders: "", maxFiles: 10, "data-field-name": name, key: name })));
+};
+
+const buildDate = ({ name, label, readOnly }) => {
+  return (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.h("ez-date-input", { enabled: !readOnly, label: label, "data-field-name": name, key: name })));
+};
+const buildTime = ({ name, label }) => {
+  return (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.h("ez-time-input", { label: label, "data-field-name": name, key: name })));
+};
+const buildTimeDate = ({ name, label }) => {
+  return (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.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 (index.h("div", { class: "col col--sd-12 col--tb-3 padding-horizontal--small" },
+    index.h("ez-number-input", { enabled: !readOnly, label: fieldLabel, precision: precision, prettyPrecision: prettyPrecision, "data-field-name": fieldName, key: fieldName })));
+}
+
+const uiBuilders = new Map();
+uiBuilders.set(core.UserInterface.LONGTEXT, buildTextArea);
+uiBuilders.set(core.UserInterface.CHECKBOX, buildCheckBox);
+uiBuilders.set(core.UserInterface.SWITCH, buildSwitch);
+uiBuilders.set(core.UserInterface.OPTIONSELECTOR, buildComboBox);
+uiBuilders.set(core.UserInterface.SEARCH, buildSearch);
+uiBuilders.set(core.UserInterface.FILE, buildFile);
+uiBuilders.set(core.UserInterface.DATE, buildDate);
+uiBuilders.set(core.UserInterface.TIME, buildTime);
+uiBuilders.set(core.UserInterface.DATETIME, buildTimeDate);
+uiBuilders.set(core.UserInterface.DECIMALNUMBER, buildDecimal);
+uiBuilders.set(core.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 index.h("ez-collapsible-box", { label: source.label }, fieldSet.items.map(fi => buildField(fi)));
+  }
+  else {
+    return buildField(source);
+  }
+};
+
+const FormSheet = ({ store, source }) => {
+  return (index.h("div", { class: "box__container" },
+    index.h("div", { class: "row padding-vertical--small" }, source.items.map(item => index.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;
+};
+
+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 = core.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 = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+  }
+  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.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(index.h("ez-tabselector", { onEzChange: (evt) => this._store.dispatch(changeTab(evt.detail)), selectedTab: currentSheet.name }, allSheets.map(s => index.h("ez-tab", { tabKey: s.name, label: s.label }))));
+    }
+    result.push(index.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 === core.Action.RECORDS_COPIED) {
+      const metadata = selectFormMetadata(this._store.getState());
+      const cleanFields = metadata.getCleanOnCopyFields();
+      if (cleanFields) {
+        const records = action.payload;
+        return new core.DataUnitAction(core.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 core.DataUnit("ez-form");
+    }
+    this.dataUnit.addInterceptor(this);
+    this.dataUnit.subscribe(action => {
+      if (action.type === core.Action.METADATA_LOADED) {
+        this.processMetadata();
+      }
+    });
+    this._dataBinder = new DataBinder(this.dataUnit);
+    this._store = redux.createStore(formReducer);
+    this._store.subscribe(() => index.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 (index.h(index.Host, null, this.isStatic() ? null : this.getDynamicContent()));
+  }
+  get _element() { return index.getElement(this); }
+  static get watchers() { return {
+    "config": ["configChanged"]
+  }; }
+};
+EzForm.style = ezFormCss;
+
+exports.ez_form = EzForm;