@sankhyalabs/ezui 3.5.0 → 4.0.0

package/dist/collection/components/ez-tree/ez-tree.js

@@ -80,6 +80,55 @@ export class EzTree {
   async applyFilter(pattern) {
     this._tree.setFilterPattern(pattern);
   }
+  /**
+   * Atualiza um item
+   */
+  async updateItem(item) {
+    this._tree.updateItem(item);
+  }
+  /**
+   * Obtem um item pelo id
+   */
+  async getItem(id) {
+    return new Promise(resolve => {
+      const node = this._tree.getNode(id);
+      resolve(node === null || node === void 0 ? void 0 : node.item);
+    });
+  }
+  /**
+   * Obtem um array do caminho de itens da seleção atual.
+   * @returns Retorna um array do caminho de itens da seleção atual.
+   */
+  async getCurrentPath() {
+    var _a, _b, _c;
+    const node = (_a = this._tree) === null || _a === void 0 ? void 0 : _a.getNode(this.selectedId);
+    if (node == undefined) {
+      return;
+    }
+    const currentPath = [];
+    let parentNode;
+    let parentItem = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.item;
+    currentPath.push(this.getItemPathAttrs(node.item));
+    while (parentItem != undefined) {
+      currentPath.unshift(this.getItemPathAttrs(parentItem));
+      parentNode = this._tree.getNode(parentItem.id);
+      parentItem = (_c = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _c === void 0 ? void 0 : _c.item;
+    }
+    return currentPath;
+  }
+  /**
+   * Obtem o item pai a partir de um id
+   */
+  async getParent(id) {
+    return new Promise(resolve => {
+      var _a;
+      const node = this._tree.getNode(id);
+      if (node) {
+        resolve((_a = node.parent) === null || _a === void 0 ? void 0 : _a.item);
+      }
+      resolve(undefined);
+    });
+  }
   observeItems(newValue, oldValue) {
     if (ObjectUtils.objectToString(newValue) !== ObjectUtils.objectToString(oldValue)) {
       this._tree.load(this.items || []);
@@ -122,6 +171,9 @@ export class EzTree {
       event.preventDefault();
     }
   }
+  getItemPathAttrs({ id, label }) {
+    return { id, label };
+  }
   openClose(item) {
     if (item == undefined) {
       return;
@@ -205,9 +257,6 @@ export class EzTree {
     if (node) {
       this.value = node.item;
     }
-    else {
-      this.selectedId = undefined;
-    }
   }
   render() {
     ElementIDUtils.addIDInfoIfNotExists(this._element, 'ezTree');
@@ -518,6 +567,105 @@ export class EzTree {
           "text": "Efetua a sele\u00E7\u00E3o de um item.",
           "tags": []
         }
+      },
+      "updateItem": {
+        "complexType": {
+          "signature": "(item: ITreeItem) => Promise<void>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "ITreeItem": {
+              "location": "import",
+              "path": "./interfaces/ITreeItem"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Atualiza um item",
+          "tags": []
+        }
+      },
+      "getItem": {
+        "complexType": {
+          "signature": "(id: string) => Promise<ITreeItem>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "ITreeItem": {
+              "location": "import",
+              "path": "./interfaces/ITreeItem"
+            }
+          },
+          "return": "Promise<ITreeItem>"
+        },
+        "docs": {
+          "text": "Obtem um item pelo id",
+          "tags": []
+        }
+      },
+      "getCurrentPath": {
+        "complexType": {
+          "signature": "() => Promise<Array<ITreeItem>>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "ITreeItem": {
+              "location": "import",
+              "path": "./interfaces/ITreeItem"
+            },
+            "Array": {
+              "location": "global"
+            },
+            "Node": {
+              "location": "import",
+              "path": "./types/Node"
+            }
+          },
+          "return": "Promise<ITreeItem[]>"
+        },
+        "docs": {
+          "text": "Obtem um array do caminho de itens da sele\u00E7\u00E3o atual.",
+          "tags": [{
+              "name": "returns",
+              "text": "Retorna um array do caminho de itens da sele\u00E7\u00E3o atual."
+            }]
+        }
+      },
+      "getParent": {
+        "complexType": {
+          "signature": "(id: string) => Promise<ITreeItem>",
+          "parameters": [{
+              "tags": [],
+              "text": ""
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "ITreeItem": {
+              "location": "import",
+              "path": "./interfaces/ITreeItem"
+            }
+          },
+          "return": "Promise<ITreeItem>"
+        },
+        "docs": {
+          "text": "Obtem o item pai a partir de um id",
+          "tags": []
+        }
       }
     };
   }

package/dist/collection/components/ez-tree/types/Node.js

@@ -81,7 +81,13 @@ export class Node {
     return this._isLazyLoad && !this._childrenLoaded;
   }
   isExpandable() {
-    return this._isLazyLoad || this.children.size > 0 || Array.isArray(this.item.children);
+    if (this._isLazyLoad) {
+      return true;
+    }
+    if (this.children.size > 0) {
+      return true;
+    }
+    return false;
   }
   getChildren() {
     if (this.isPlaceHolder) {

package/dist/collection/components/ez-tree/types/Tree.js

@@ -57,6 +57,12 @@ export class Tree extends Node {
       return;
     }
     Object.keys(item).forEach(attrib => node.item[attrib] = item[attrib]);
+    if (item.children == undefined) {
+      node.children.clear();
+    }
+    else if (Array.isArray(item.children)) {
+      node.updateChildren(item.children);
+    }
     this._changeCallback();
   }
   async open(path) {

package/dist/collection/{components/ez-form → utils/form}/DataBinder.js

@@ -1,4 +1,5 @@
-import { ApplicationContext, Action, WaitingChangeException } from "@sankhyalabs/core";
+import { ApplicationContext, Action, WaitingChangeException, DataUnitAction } from "@sankhyalabs/core";
+import ApplicationUtils from "../ApplicationUtils";
 export default class DataBinder {
   constructor(dataUnit) {
     this._invalidFields = new Map();
@@ -28,15 +29,21 @@ export default class DataBinder {
     this._fields = new Map();
     this._dataUnit = dataUnit;
     this._dataUnit.subscribe(this.onDataUnitEvent);
+    this._dataUnit.addInterceptor(this);
   }
-  bind(fields) {
+  bind(fields, currentContextName, formMetadata, recordsValidator) {
     fields.forEach(fieldElement => {
-      const fieldName = fieldElement.dataset.fieldName;
-      this.updateBind(fieldName, fieldElement);
+      const { fieldName, contextName } = fieldElement.dataset;
+      if (contextName == undefined || contextName === currentContextName) {
+        this.updateBind(fieldName, fieldElement);
+      }
     });
+    this._formMetadata = formMetadata;
+    this._recordsValidator = recordsValidator;
   }
   onDisconnectedCallback() {
     this._dataUnit.unsubscribe(this.onDataUnitEvent);
+    this._dataUnit.removeInterceptor(this);
   }
   markInvalid(field) {
     this._invalidFields.set(field.name, field);
@@ -69,6 +76,67 @@ export default class DataBinder {
       }
     }
   }
+  validate() {
+    return new Promise((accept, reject) => {
+      var _a;
+      const records = this._dataUnit.getModifiedRecords();
+      for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        const invalidResults = [];
+        let validationResult = this.validateRequired(record);
+        if (validationResult && !validationResult.isValid) {
+          invalidResults.push(validationResult);
+        }
+        validationResult = (_a = this._recordsValidator) === null || _a === void 0 ? void 0 : _a.validateRecord(record);
+        if (validationResult && !validationResult.isValid) {
+          invalidResults.push(validationResult);
+        }
+        if (invalidResults.length > 0) {
+          this.processValidationResult(invalidResults);
+          reject();
+          break;
+        }
+      }
+      return accept();
+    });
+  }
+  validateRequired(record) {
+    const requiredFields = this._formMetadata.getRequiredFields();
+    const invalidFields = [];
+    new Set(requiredFields).forEach(field => {
+      const value = record[field];
+      if (value == undefined || value === "") {
+        const errorMessage = this.getErrorMessage(field);
+        if (errorMessage) {
+          invalidFields.push({ name: field, message: errorMessage });
+        }
+        else {
+          invalidFields.push({ name: field, message: "Essa informação é obrigatória" });
+        }
+      }
+    });
+    if (invalidFields.length > 0) {
+      return { isValid: false, invalidFields, infoMessage: "Há pelo menos um campo obrigatório não preenchido." };
+    }
+    return undefined;
+  }
+  processValidationResult(validationResult) {
+    validationResult.forEach(invalidResult => {
+      const invalidFields = invalidResult.invalidFields;
+      if (invalidFields) {
+        invalidFields.forEach(field => {
+          this.markInvalid(field);
+        });
+      }
+      if (invalidResult.infoMessage) {
+        ApplicationUtils.info(invalidResult.infoMessage);
+      }
+      if (invalidResult.errorMessage) {
+        const { errorTitle, errorMessage } = invalidResult;
+        ApplicationUtils.error(errorTitle, errorMessage);
+      }
+    });
+  }
   updateErrorMessage(fieldName, field) {
     const invalidField = this._invalidFields.get(fieldName);
     if (invalidField) {
@@ -161,6 +229,52 @@ export default class DataBinder {
       field["maxFiles"] = ((_b = descriptor.properties) === null || _b === void 0 ? void 0 : _b.MAX_FILES) || 0;
     }
   }
+  interceptAction(action) {
+    var _a;
+    if (action.type === Action.RECORDS_COPIED) {
+      const cleanFields = this._formMetadata.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;
+        }));
+      }
+    }
+    if (action.type === Action.SAVING_DATA) {
+      return new Promise((resolve) => {
+        this.validate()
+          .then(() => resolve(action))
+          .catch(() => { });
+      });
+    }
+    if (action.type === Action.RECORDS_ADDED) {
+      const defaultValues = (_a = this._formMetadata) === null || _a === void 0 ? void 0 : _a.getDefaultValues();
+      if (defaultValues) {
+        const records = action.payload;
+        return new DataUnitAction(Action.RECORDS_ADDED, records.map(record => {
+          const newRecord = Object.assign({}, record);
+          for (const field in defaultValues) {
+            const defaultValue = this.getFormattedValue(defaultValues[field]);
+            const recordValue = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+            newRecord[field] = this._dataUnit.valueFromString(field, recordValue);
+          }
+          return newRecord;
+        }));
+      }
+    }
+    return action;
+  }
+  getFormattedValue(defaultValue) {
+    if (defaultValue == undefined || typeof defaultValue !== "object") {
+      return defaultValue;
+    }
+    if ("formattedValue" in defaultValue) {
+      return defaultValue.formattedValue;
+    }
+    return defaultValue.value;
+  }
 }
 class Bind {
   constructor() {

package/dist/collection/{components/ez-form → utils/form}/FormMetadata.js

@@ -1,4 +1,6 @@
-import { UserInterface } from "@sankhyalabs/core";
+import { DateUtils, UserInterface } from "@sankhyalabs/core";
+const DETAIL_PATTERN = /child\[([^\]]+)\]/;
+const REGEX_DEFAULT_VAR_KEY = /\$\{.+\}/;
 export class FormMetadata {
   constructor() {
     this._sheets = new Map();
@@ -6,6 +8,10 @@ export class FormMetadata {
     this._cleanOnCopyFields = [];
     this._defaultValues = {};
   }
+  static getDetailName(name) {
+    const result = DETAIL_PATTERN.exec(name);
+    return result ? result[1] : undefined;
+  }
   getSheet(name) {
     return this._sheets.get(name);
   }
@@ -14,47 +20,64 @@ export class FormMetadata {
   }
   addSheet(sheet) {
     this._sheets.set(sheet.name, sheet);
-    this._requiredFields = this._requiredFields.concat(sheet.requiredFields);
-    this._cleanOnCopyFields = this._cleanOnCopyFields.concat(sheet.cleanOnCopyFields);
-    this._defaultValues = sheet.defaultValues;
+  }
+  addRequiredFields(fields) {
+    this._requiredFields = this._requiredFields.concat(fields);
   }
   getRequiredFields() {
     return this._requiredFields;
   }
+  addCleanOnCopyFields(fields) {
+    this._cleanOnCopyFields = this._cleanOnCopyFields.concat(fields);
+  }
   getCleanOnCopyFields() {
     return this._cleanOnCopyFields;
   }
+  addDefaultValues(defaultValues) {
+    return this._defaultValues = Object.assign(Object.assign({}, this._defaultValues), defaultValues);
+  }
   getDefaultValues() {
-    return this._defaultValues;
+    const result = {};
+    Object.entries(this._defaultValues).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        const result = REGEX_DEFAULT_VAR_KEY.exec(value);
+        if (result) {
+          value = this.getDefaultVar(result[0]);
+        }
+      }
+      result[key] = value;
+    });
+    return result;
+  }
+  getDefaultVar(name) {
+    if (name === "${data}") {
+      return DateUtils.getToday();
+    }
+    if (name === "${datahora}") {
+      return DateUtils.getToday(true);
+    }
+    return this._defaultVars ? this._defaultVars.get(name) : undefined;
+  }
+  setDefaultVars(vars) {
+    this._defaultVars = vars;
   }
 }
-export const buildFromDataUnit = (dataUnit) => {
+export const buildFormConfigFromDataUnit = (dataUnit) => {
   const unitMD = dataUnit.metadata;
-  const metadata = new FormMetadata();
+  let fields;
   if (unitMD) {
-    const visibleFields = (unitMD.fields || []).filter(descriptor => descriptor.visible !== false);
-    const fields = visibleFields.map(descriptor => buildFormField(descriptor));
-    let defaultValues = {};
-    visibleFields
-      .filter(descriptor => descriptor.defaultValue)
-      .forEach((descriptor) => defaultValues[descriptor.name] = descriptor.defaultValue);
-    metadata.addSheet({
-      name: unitMD.name,
-      label: unitMD.label,
-      fields,
-      requiredFields: visibleFields
-        .filter(descriptor => descriptor.required)
-        .map(descriptor => descriptor.name),
-      cleanOnCopyFields: visibleFields
-        .filter(descriptor => { var _a, _b; return ((_a = descriptor.properties) === null || _a === void 0 ? void 0 : _a.cleanOnCopy) || ((_b = descriptor.properties) === null || _b === void 0 ? void 0 : _b.autoNum); })
-        .map(descriptor => descriptor.name),
-      defaultValues
-    });
+    fields = unitMD.fields
+      .filter(descriptor => descriptor.visible !== false)
+      .map(descriptor => { return { name: descriptor.name, defaultValue: descriptor.defaultValue }; });
   }
-  return metadata;
+  const config = { fields };
+  return config;
 };
-export const buildFromConfig = (config, dataUnit) => {
+export const buildFormMetadata = (config, dataUnit, includeDetails = false) => {
   var _a, _b;
+  if (config == undefined) {
+    config = buildFormConfigFromDataUnit(dataUnit);
+  }
   const sheets = new Map();
   const hiddenTabs = new Map();
   const requiredFields = [];
@@ -66,7 +89,7 @@ export const buildFromConfig = (config, dataUnit) => {
     }
   });
   (_b = config === null || config === void 0 ? void 0 : config.fields) === null || _b === void 0 ? void 0 : _b.forEach((field) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     if (field.visible !== false) {
       const tabConfig = getTabConfig(field.tab || "__main", sheets);
       if (hiddenTabs.has(tabConfig.label)) {
@@ -83,29 +106,46 @@ export const buildFromConfig = (config, dataUnit) => {
           requiredFields.push(field.name);
         }
         const cleanOnCopy = field.cleanOnCopy == undefined ? (_a = descriptor.properties) === null || _a === void 0 ? void 0 : _a.cleanOnCopy : field.cleanOnCopy;
-        if (cleanOnCopy || ((_b = descriptor.properties) === null || _b === void 0 ? void 0 : _b.autoNum) || ((_c = descriptor.properties) === null || _c === void 0 ? void 0 : _c.cleanOnCopy)) {
+        if (cleanOnCopy || ((_b = descriptor.properties) === null || _b === void 0 ? void 0 : _b.cleanOnCopy)) {
           cleanOnCopyFields.push(field.name);
         }
-        const defaultValue = field.defaultValue == undefined ? (_d = descriptor.properties) === null || _d === void 0 ? void 0 : _d.defaultValue : field.defaultValue;
+        let defaultValue = field.defaultValue == undefined ? (_c = descriptor.properties) === null || _c === void 0 ? void 0 : _c.defaultValue : field.defaultValue;
         if (defaultValue) {
-          defaultValues[field.name] = field.defaultValue;
+          if ((typeof defaultValue === "object") && defaultValue["type"] === "V") {
+            // Atualmente a configuração do formulário eventualmente deposita um objeto
+            // prototipado como {type: "V", value: "${nome.de.variavel}"} para campos com
+            // valor padrão do tipo variável. Dessa forma precisamos "desenvelopar" o valor
+            // para que a variável chegue corretamente a seu destino.
+            defaultValue = defaultValue["value"];
+          }
+          defaultValues[field.name] = defaultValue;
         }
       }
     }
   });
   const metadata = new FormMetadata();
+  metadata.setDefaultVars(config.defaultVars);
+  if (includeDetails) {
+    const unitMD = dataUnit.metadata;
+    if (unitMD != undefined && unitMD.children != undefined) {
+      unitMD.children.forEach(child => {
+        const { label, name, fields } = buildDetailSheet(child);
+        sheets.set({ name, label }, fields);
+      });
+    }
+  }
   Array.from(sheets.entries())
     .sort(sortTabs)
     .forEach(([key, fields]) => {
     metadata.addSheet({
       label: (key.label === "__main") ? "Principal" : key.label,
-      name: key.label,
-      fields,
-      requiredFields,
-      cleanOnCopyFields,
-      defaultValues
+      name: key.name || key.label,
+      fields
     });
   });
+  metadata.addRequiredFields(requiredFields);
+  metadata.addCleanOnCopyFields(cleanOnCopyFields);
+  metadata.addDefaultValues(defaultValues);
   return metadata;
 };
 const buildFormField = (descriptor, config) => {
@@ -135,3 +175,10 @@ const getTabConfig = (tab, sheets) => {
 const sortTabs = (a, b) => {
   return a[0].label == '__main' ? -1 : (a[0].order || 10000) - (b[0].order || 10000);
 };
+const buildDetailSheet = (child) => {
+  return {
+    name: `child[${child.name}]`,
+    label: child.label,
+    fields: []
+  };
+};

package/dist/collection/utils/form/index.js

@@ -0,0 +1,2 @@
+export { FormMetadata, buildFormMetadata, buildFormConfigFromDataUnit } from "./FormMetadata";
+export { default as DataBinder } from "./DataBinder";

package/dist/collection/utils/index.js

@@ -2,3 +2,5 @@ export { default as ApplicationUtils } from './ApplicationUtils';
 export { default as CSSVarsUtils } from './CSSVarsUtils';
 export { DialogType } from '../components/ez-dialog/DialogType';
 export { CheckMode } from '../components/ez-check/CheckMode';
+export { FormMetadata } from './form/FormMetadata';
+export { default as DataBinder } from './form/DataBinder';