@sankhyalabs/ezui 1.1.75 → 1.1.78

package/dist/esm/ApplicationUtils-01280a9d.js

@@ -0,0 +1,33 @@
+class ApplicationUtils {
+  static async showDialog(title, message, icon = null, confirm, critical = false) {
+    return new Promise(resolve => {
+      let dialog = document.querySelector("ez-dialog");
+      if (!dialog) {
+        dialog = document.createElement("ez-dialog");
+        window.document.body.appendChild(dialog);
+      }
+      dialog.show(title, message, critical, confirm, icon).then(ok => resolve(ok));
+    });
+  }
+  static async alert(title, message, icon = null) {
+    return ApplicationUtils.showDialog(title, message, icon, false, false);
+  }
+  static async error(title, message, icon = null) {
+    return ApplicationUtils.showDialog(title, message, icon, false, true);
+  }
+  static async confirm(title, message, icon = null, critical = false) {
+    return ApplicationUtils.showDialog(title, message, icon, true, critical);
+  }
+  static async info(message) {
+    let toast = document.querySelector("ez-toast");
+    if (!toast) {
+      toast = document.createElement("ez-toast");
+      window.document.body.appendChild(toast);
+    }
+    toast.message = message;
+    toast.fadeTime = 4000;
+    toast.show();
+  }
+}
+
+export { ApplicationUtils as A };

package/dist/esm/AssetsUtils-3803e935.js

@@ -0,0 +1,22 @@
+import { a as getAssetPath, s as setAssetPath } from './index-1dacecd3.js';
+
+const getSpritePath = (sprite) => `${getContextAssetsPath("../assets/actions-sprite.svg")}#${sprite}`;
+let ctxLoaded = false;
+function getContextAssetsPath(resource) {
+  if (!ctxLoaded) {
+    const scriptElem = document.querySelector("script[data-ezui-assets-url]");
+    if (scriptElem) {
+      let assetsPath = scriptElem.dataset.ezuiAssetsUrl;
+      if (assetsPath) {
+        if (assetsPath.startsWith('/')) {
+          assetsPath = window.location.origin + assetsPath;
+        }
+        setAssetPath(assetsPath);
+      }
+    }
+    ctxLoaded = true;
+  }
+  return getAssetPath(resource);
+}
+
+export { getSpritePath as g };

package/dist/esm/CSSVarsUtils-aeee9825.js

@@ -0,0 +1,16 @@
+class CSSVarsUtils {
+  static applyVarsTextInput(host, child) {
+    if (child) {
+      CSSVarsUtils.applyIfExists(host, child, '--ez-text-input__input--background-color');
+      CSSVarsUtils.applyIfExists(host, child, '--ez-text-input__input--border-color');
+    }
+  }
+  static applyIfExists(host, element, varName) {
+    const prop = getComputedStyle(host).getPropertyValue(varName);
+    if (prop) {
+      element.style.setProperty(varName, prop);
+    }
+  }
+}
+
+export { CSSVarsUtils as C };

package/dist/esm/DataUnit-1cd45202.js

@@ -0,0 +1,464 @@
+import { A as ApplicationUtils } from './ApplicationUtils-01280a9d.js';
+
+function changeFieldValue(dataUnit, recordId, fieldName, value) {
+  return {
+    type: "FORM/CHANGEFIELD",
+    payload: { dataUnit, recordId, fieldName, value }
+  };
+}
+function changeTab(formId, index) {
+  return {
+    type: "FORM/CHANGETAB",
+    payload: { formId, index }
+  };
+}
+function clearEdition(dataUnit, recordsLimit) {
+  return {
+    type: "FORM/CLEAREDITION",
+    payload: {
+      dataUnit,
+      recordsLimit
+    }
+  };
+}
+function collapseExpandGroup(collapseId, collapsed) {
+  return {
+    type: "FORM/COLLAPSEGROUP",
+    payload: { collapseId, collapsed }
+  };
+}
+function previousRecord(dataUnit) {
+  return {
+    type: "FORM/NAVIGATE",
+    payload: {
+      dataUnit,
+      limit: 0,
+      backward: true
+    }
+  };
+}
+function nextRecord(dataUnit, limit) {
+  return {
+    type: "FORM/NAVIGATE",
+    payload: {
+      dataUnit,
+      limit,
+      backward: false
+    }
+  };
+}
+function insertRecord(dataUnit, insertionIndex) {
+  return {
+    type: "FORM/INSERT",
+    payload: {
+      dataUnit,
+      insertionIndex
+    }
+  };
+}
+function formLoad() {
+  return {
+    type: "FORM/LOAD"
+  };
+}
+function dataLoading(dataUnit) {
+  return {
+    type: "FORM/DATALOADING",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function savingChanges(dataUnit) {
+  return {
+    type: "FORM/SAVINGCHANGES",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function dataLoaded(dataUnit) {
+  return {
+    type: "FORM/DATALOADED",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function changesSaved(dataUnit) {
+  return {
+    type: "FORM/CHANGESSAVED",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function removingRecord(dataUnit) {
+  return {
+    type: "FORM/REMOVINGRECORD",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function recordRemoved(dataUnit) {
+  return {
+    type: "FORM/RECORDREMOVED",
+    payload: {
+      dataUnit
+    }
+  };
+}
+function invalidField(tabController, tabIndex, dataUnit, recordIndex, recordId, fieldName, errorMessage) {
+  return {
+    type: "FORM/INVALIDFIELD",
+    payload: {
+      tabController,
+      tabIndex,
+      dataUnit,
+      recordId,
+      recordIndex,
+      fieldName,
+      errorMessage
+    }
+  };
+}
+function showHideNavigationButtons(buttonName, status) {
+  return {
+    type: "FORM/SHOWHIDENAVBTN",
+    payload: {
+      buttonName,
+      status
+    }
+  };
+}
+
+//histórico
+const selectCurrentTab = (state, formName) => {
+  const data = state.hist.present.currentTabIndex;
+  return data[formName] || 0;
+};
+const selectIsCollapsedFieldSet = (state, fieldSetName) => {
+  const data = state.hist.present.collapsedGroups;
+  return data[fieldSetName];
+};
+const selectRecordChanges = (state, dataUnit, recordId) => {
+  const data = selectDataUnitChanges(state, dataUnit);
+  return data ? data[recordId] : undefined;
+};
+const selectDataUnitChanges = (state, dataUnit) => {
+  const data = state.hist.present.changes;
+  return data[dataUnit];
+};
+const selectCurrentRecordIndex = (state, dataUnit) => {
+  const data = state.hist.present.currentRecordIndex;
+  return data[dataUnit] || 0;
+};
+const selectNewRecordIndex = (state, dataUnit) => {
+  const data = state.hist.present.newRecordIndex;
+  return data[dataUnit] || 0;
+};
+//não histórico
+const selectLoadingData = (state, dataUnit) => {
+  const data = state.nonhist.dataLoading;
+  return data[dataUnit];
+};
+const selectErrorMessage = (state, dataUnit, recordId, fieldName) => {
+  const data = state.nonhist.invalidFields;
+  const dataUnitMessages = data[dataUnit] || {};
+  const recordMessages = dataUnitMessages[recordId] || {};
+  return recordMessages[fieldName] || "";
+};
+const selectVisibleButtons = state => state.nonhist.visibleButtons;
+
+class DataUnit {
+  constructor(name, unitLabel, cardinality = "1", parentDU = null) {
+    this.name = name;
+    this.unitLabel = unitLabel;
+    this.cardinality = cardinality;
+    this._children = [];
+    this._fields = new Map();
+    this._requiredFields = [];
+    if (parentDU != null) {
+      parentDU._children.push(this);
+      this.parentDU = parentDU;
+      this.parentDUName = parentDU.name;
+    }
+  }
+  set store(store) {
+    this._store = store;
+  }
+  set fields(value) {
+    if (value) {
+      value.forEach(f => this.addFieldMetadata(f));
+    }
+  }
+  addFieldMetadata(field) {
+    this._fields.set(field.name, field);
+    if (field.required) {
+      this._requiredFields.push(field);
+    }
+  }
+  getFieldMetadata(name) {
+    if (this._fields) {
+      return this._fields.get(name);
+    }
+    return undefined;
+  }
+  get requiredFields() {
+    return this._requiredFields;
+  }
+  isLoading() {
+    return selectLoadingData(this._store.getState(), this.name);
+  }
+  hasChanges() {
+    const state = this._store.getState();
+    return selectDataUnitChanges(state, this.name) !== undefined || selectNewRecordIndex(state, this.name) > 0;
+  }
+  hasNext() {
+    return selectCurrentRecordIndex(this._store.getState(), this.name) < (this.records.length - 1);
+  }
+  hasPrevious() {
+    return selectCurrentRecordIndex(this._store.getState(), this.name) > 0;
+  }
+  hasCurrentRecord() {
+    return this.getCurrentRecord() != undefined;
+  }
+  previous() {
+    this._store.dispatch(previousRecord(this.name));
+  }
+  next() {
+    this._store.dispatch(nextRecord(this.name, this.records.length));
+  }
+  getValue(fieldName) {
+    const currentRecord = this.getCurrentRecord();
+    if (!currentRecord) {
+      return undefined;
+    }
+    const changes = this.getRecordChanges(currentRecord);
+    return changes && changes[fieldName] !== undefined ? changes[fieldName] : currentRecord[fieldName] || null;
+  }
+  getErrorMessage(fieldName) {
+    const currentRecord = this.getCurrentRecord();
+    return selectErrorMessage(this._store.getState(), this.name, currentRecord === null || currentRecord === void 0 ? void 0 : currentRecord.record__id, fieldName);
+  }
+  changeValue(fieldName, newValue) {
+    if (this.records.length == 0) {
+      this.insert();
+    }
+    if (this._changeDeboucing) {
+      window.clearTimeout(this._changeDeboucing);
+    }
+    this._changeDeboucing = window.setTimeout(() => {
+      const currentRecord = this.getCurrentRecord();
+      this._store.dispatch(changeFieldValue(this.name, currentRecord.record__id, fieldName, newValue));
+    }, 100);
+  }
+  cancel() {
+    this.records = this.records.filter(r => !r.record__id.startsWith("NEW_"));
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+  }
+  insert() {
+    const insertionIndex = this.records.length;
+    const newRecordIndex = selectNewRecordIndex(this._store.getState(), this.name);
+    const newRecord = { record__id: "NEW_" + (newRecordIndex + 1) };
+    this.bindToParent(newRecord);
+    this.records.push(newRecord);
+    this._store.dispatch(insertRecord(this.name, insertionIndex));
+  }
+  buildChange(r) {
+    const duChanges = selectDataUnitChanges(this._store.getState(), this.name);
+    let recordChanges;
+    if (duChanges) {
+      recordChanges = duChanges[r.record__id];
+    }
+    let subChanges = [];
+    this._children.forEach(duChild => {
+      subChanges = subChanges.concat(duChild.getSubChanges(r.record__id));
+    });
+    if (recordChanges || subChanges.length > 0) {
+      const change = {
+        "__data__unit": this.name,
+        "__record__id": r.record__id,
+        "__sub__changes": subChanges
+      };
+      if (recordChanges) {
+        Object.keys(recordChanges).forEach(fieldName => { });
+      }
+      return change;
+    }
+    return undefined;
+  }
+  getSubChanges(id) {
+    const result = [];
+    if (this._records) {
+      this._records.filter(r => r.parent__record__id === id).forEach(r => {
+        const c = this.buildChange(r);
+        if (c) {
+          result.push(c);
+        }
+      });
+    }
+    return result;
+  }
+  getChangesToSave() {
+    let result = [];
+    if (this._records) {
+      this._records.forEach(r => {
+        const change = this.buildChange(r);
+        if (change) {
+          result.push(change);
+        }
+      });
+    }
+    return result;
+  }
+  save() {
+    if (!this.validateRecords("SAVE")) {
+      return;
+    }
+    this._store.dispatch(savingChanges(this.name));
+    let saveResult;
+    if (this.saveExecutor) {
+      saveResult = this.saveExecutor(this.getChangesToSave());
+    }
+    if (saveResult instanceof Promise) {
+      saveResult
+        .then(r => this.processSaveResult(r))
+        .catch(e => {
+        this._store.dispatch(dataLoaded(this.name));
+        ApplicationUtils.error("Falha ao tentar salvar", e);
+      });
+    }
+    else {
+      this.processSaveResult(saveResult);
+    }
+  }
+  load() {
+    this._store.dispatch(dataLoading(this.name));
+    let result;
+    if (this.loadExecutor) {
+      result = this.loadExecutor({ dataUnit: this.name });
+    }
+    if (result instanceof Promise) {
+      result.then(r => this.processLoadResult(r));
+    }
+    else {
+      this.processLoadResult(result);
+    }
+  }
+  remove() {
+    const currentIndex = selectCurrentRecordIndex(this._store.getState(), this.name);
+    this._store.dispatch(removingRecord(this.name));
+    let removeResult;
+    if (this.removeExecutor) {
+      const record = this.getCurrentRecord();
+      removeResult = this.removeExecutor({ dataUnit: this.name, recordId: record.record__id, record });
+    }
+    else {
+      removeResult = true;
+    }
+    if (removeResult) {
+      if (removeResult instanceof Promise) {
+        removeResult.then(r => this.processRemoveResult(r, currentIndex));
+      }
+      else {
+        this.processRemoveResult(removeResult, currentIndex);
+      }
+    }
+  }
+  processSaveResult(result) {
+    if (result) {
+      if (result instanceof Array) {
+        result.forEach(item => this.processSaveResult(item));
+      }
+      else {
+        if (result.__data__unit === this.name) {
+          if (this.cardinality === "1") {
+            this.records = [this.buildRecordFromSaveResult(this.records[0], result)];
+          }
+        }
+      }
+    }
+    //FIXME: Isso está errado! tem que limpar todas as edições
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    this._store.dispatch(changesSaved(this.name));
+  }
+  buildRecordFromSaveResult(baseRecord, saveResult) {
+    const newRecord = baseRecord ? Object.assign({}, baseRecord) : { record__id: "" };
+    Object.keys(saveResult).forEach(attrib => {
+      if (!attrib.startsWith("__")) {
+        newRecord[attrib] = saveResult[attrib];
+      }
+    });
+    return newRecord;
+  }
+  processLoadResult(records) {
+    this.records = records;
+    this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    this._store.dispatch(dataLoaded(this.name));
+  }
+  processRemoveResult(removed, recordIndex) {
+    if (removed) {
+      this.records.splice(recordIndex, 1);
+      this._store.dispatch(clearEdition(this.name, this.records.length - 1));
+    }
+    this._store.dispatch(recordRemoved(this.name));
+  }
+  set records(records) {
+    this._records = records;
+    if (this.parentDU) {
+      this._records.forEach(r => this.bindToParent(r));
+    }
+  }
+  bindToParent(r) {
+    if (this.parentDU) {
+      const parentRecord = this.parentDU.getCurrentRecord();
+      if (parentRecord) {
+        r.parent__record__id = parentRecord.record__id;
+      }
+    }
+  }
+  get records() {
+    if (!this._records) {
+      this._records = [];
+    }
+    return this._records;
+  }
+  getCurrentRecord() {
+    const currentIndex = selectCurrentRecordIndex(this._store.getState(), this.name);
+    return this.records[currentIndex];
+  }
+  getRecordChanges(currentRecord = undefined) {
+    if (currentRecord === undefined) {
+      currentRecord = this.getCurrentRecord();
+    }
+    return currentRecord ? selectRecordChanges(this._store.getState(), this.name, currentRecord.record__id) : undefined;
+  }
+  validateRecords(triggedBy = "UNKNOWN") {
+    if (!this.recordsValidator) {
+      return true;
+    }
+    const duChanges = selectDataUnitChanges(this._store.getState(), this.name);
+    const recordsToValidate = [];
+    this.records.forEach((record, i) => {
+      const changes = duChanges ? duChanges[record.record__id] : undefined;
+      if (changes) {
+        recordsToValidate.push(Object.assign(Object.assign(Object.assign({}, record), changes), { record__index: i, record__changedfields: Object.keys(changes) }));
+      }
+    });
+    const result = this.recordsValidator.validateRecords(this, recordsToValidate, triggedBy);
+    if (result.message) {
+      ApplicationUtils.info(result.message);
+    }
+    return result.isValid;
+  }
+}
+var DependencyType;
+(function (DependencyType) {
+  DependencyType["SEARCHING"] = "SEARCHING";
+  DependencyType["REQUIREMENT"] = "REQUIREMENT";
+  DependencyType["VISIBILITY"] = "REQUIREMENT";
+})(DependencyType || (DependencyType = {}));
+
+export { DependencyType as D, selectCurrentTab as a, selectVisibleButtons as b, collapseExpandGroup as c, changeTab as d, showHideNavigationButtons as e, formLoad as f, DataUnit as g, invalidField as i, selectIsCollapsedFieldSet as s };

package/dist/esm/DateUtils-0a1bbd7a.js

@@ -0,0 +1,44 @@
+class DateUtils {
+    static clearTime(date, adjustDayLightSavingTime = true) {
+        const newDate = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+        return adjustDayLightSavingTime ? DateUtils.adjustDLST(newDate) : newDate;
+    }
+    static strToDate(strValue, adjustDayLightSavingTime = true, monthYearMode = false) {
+        /** monthYearMode é um booleano para usar o formato MM/YYYY.
+         * Quando ativado, é retornado o primeiro dia do mês apenas para construir a data.
+         * Não há necessidade de verificar o horário de verão quando utilizado esse modo. */
+        let parts;
+        if (monthYearMode) {
+            parts = /^(1[0-2]|0[1-9]|[1-9])[^\d]?(\d{2}|\d{4})(?:\s(\d{1,2}):(\d{1,2}):?(\d{0,2}))?$/.exec(strValue);
+        }
+        else {
+            parts = /^(3[01]|[1-2]\d|0[1-9]|[1-9])[^\d]?(1[0-2]|0[1-9]|[1-9])[^\d]?(\d{2}|\d{4})(?:\s(\d{1,2}):(\d{1,2}):?(\d{0,2}))?$/.exec(strValue);
+        }
+        if (!parts) {
+            return undefined;
+        }
+        var day = monthYearMode ? 1 : Number(parts[1]);
+        var month = Number(parts[(monthYearMode ? 1 : 2)]);
+        var year = Number(parts[(monthYearMode ? 2 : 3)]);
+        var hour = Number(parts[(monthYearMode ? 3 : 4)] || 0);
+        var min = Number(parts[(monthYearMode ? 4 : 5)] || 0);
+        var sec = Number(parts[(monthYearMode ? 5 : 6)] || 0);
+        if (year < 100) {
+            year += year < 30 ? 2000 : 1900;
+        }
+        let date = new Date(year, month - 1, day, hour, min, sec, 0);
+        if (adjustDayLightSavingTime === true && !monthYearMode && hour == 0) {
+            date = DateUtils.adjustDLST(date);
+        }
+        return date;
+    }
+    static adjustDLST(date) {
+        //Work around para corrigir o Bug do horário de verão.
+        if (date.getHours() == 23) {
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1, 1, 0, 0, 0);
+        }
+        return date;
+    }
+}
+
+export { DateUtils as D };

package/dist/esm/ez-action-chip.entry.js

@@ -1,4 +1,4 @@
-import { r as registerInstance, c as createEvent, h } from './index-33153059.js';
+import { r as registerInstance, c as createEvent, h } from './index-1dacecd3.js';
 
 const ezActionChipCss = ":host{--ez-action-chip--height:36px;--ez-action-chip--border-radius:var(--border--radius-large, 24px);--ez-action-chip__border:1px solid;--ez-action-chip__border-color-strokes:var(--color--strokes, #DCE0E8);--ez-action-chip--font-size:var(--text--medium, 14px);--ez-action-chip--font-family:var(--font-pattern, Arial);--ez-action-chip--font-weight:var(--text-weight--large, 500);--ez-action-chip__label--title--primary:var(--title--primary, #919191);--ez-action-chip__label-color--disable-secondary:var(--color--disable-secondary, #F2F5F8);--ez-action-chip__label__default--background-color--hover:var(--color--primary-200, #f2faf8);--ez-action-chip__label__default--border-color--hover:var(--color--primary-600, #007a5a)}.label__container{width:fit-content;display:flex;flex-wrap:wrap;position:relative;background-color:#FFFFFF;align-items:center;align-self:center;cursor:pointer;color:var(--ez-action-chip__label--title--primary);fill:var(--ez-action-chip__label--title--primary);border:var(--ez-action-chip__border);border-radius:var(--ez-action-chip--border-radius);border-color:var(--ez-action-chip__border-color-strokes);padding-right:var(--space--medium, 12px);padding-left:var(--space--medium, 12px)}.label__container:hover{border-color:var(--ez-action-chip__label__default--border-color--hover);background-color:var(--ez-action-chip__label__default--background-color--hover)}label{display:flex;align-items:center;font-weight:var(--text-weight--large, 600);cursor:pointer;height:var(--ez-action-chip--height);font-family:var(--ez-action-chip--font-family);font-size:var(--ez-action-chip--font-size)}";
 

package/dist/esm/ez-application.entry.js

@@ -0,0 +1,22 @@
+import { r as registerInstance, c as createEvent, h } from './index-1dacecd3.js';
+
+const ezApplicationCss = "";
+
+let EzApplication = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.applicationLoaded = createEvent(this, "applicationLoaded", 7);
+  }
+  componentWillLoad() {
+    //Initizalize application
+  }
+  componentDidLoad() {
+    this.applicationLoaded.emit(true);
+  }
+  render() {
+    return (h("div", null));
+  }
+};
+EzApplication.style = ezApplicationCss;
+
+export { EzApplication as ez_application };