@sankhyalabs/sankhyablocks 1.3.33 → 1.4.0-beta.1

package/dist/components/snk-crud.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface SnkCrud extends Components.SnkCrud, HTMLElement {}
+export const SnkCrud: {
+  prototype: SnkCrud;
+  new (): SnkCrud;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/snk-crud.js

@@ -0,0 +1,133 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { A as ApplicationContext } from './index2.js';
+import { d as defineCustomElement$8 } from './snk-filter-bar2.js';
+import { d as defineCustomElement$7 } from './snk-filter-detail2.js';
+import { d as defineCustomElement$6 } from './snk-filter-item2.js';
+import { d as defineCustomElement$5 } from './snk-filter-list2.js';
+import { d as defineCustomElement$4 } from './snk-form2.js';
+import { d as defineCustomElement$3 } from './snk-grid2.js';
+import { d as defineCustomElement$2 } from './snk-taskbar2.js';
+
+const snkCrudCss = ".sc-snk-crud-h{display:flex;flex-direction:column;height:100%;width:100%}";
+
+const GRID_MODE = 0;
+const FORM_MODE = 1;
+const SnkCrud$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.actionClick = createEvent(this, "actionClick", 7);
+  }
+  async gridToForm(keepFormMode = false) {
+    this._backToGrid = !keepFormMode && await this._viewStack.getSelectedIndex() === GRID_MODE;
+    this._viewStack.show(FORM_MODE);
+  }
+  async executeAction(act) {
+    if (act === "GRID_MODE") {
+      this._viewStack.show(GRID_MODE);
+    }
+    else if (act === "FORM_MODE" || act === "UPDATE") {
+      this.gridToForm(act !== "UPDATE");
+    }
+  }
+  insertionModeHandler() {
+    this.gridToForm();
+  }
+  cancelHandler() {
+    if (this._backToGrid) {
+      this._viewStack.show(GRID_MODE);
+    }
+  }
+  componentWillLoad() {
+    let parent = this._element.parentElement;
+    while (parent) {
+      if (parent.tagName.toUpperCase() === "SNK-DATA-UNIT") {
+        this._snkDataUnit = parent;
+        this._snkDataUnit.addEventListener("insertionMode", () => this.insertionModeHandler());
+        this._snkDataUnit.addEventListener("cancelEdition", () => this.cancelHandler());
+        this._dataUnit = this._snkDataUnit.dataUnit;
+        this._dataState = this._snkDataUnit.dataState;
+        if (!this._dataUnit) {
+          this._snkDataUnit.addEventListener("dataUnitReady", (evt) => {
+            this._dataUnit = evt.detail;
+          });
+        }
+        this._snkDataUnit.addEventListener("dataStateChange", (evt) => {
+          this._dataState = evt.detail;
+        });
+        break;
+      }
+      parent = parent.parentElement;
+    }
+    if (!this.configName) {
+      const application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      this.configName = application.configName;
+    }
+  }
+  render() {
+    return (h("ez-view-stack", { ref: (ref) => this._viewStack = ref }, h("stack-item", null, h("snk-grid", { configName: this.configName, onGridDoubleClick: () => this.gridToForm(true), taskbarManager: this.taskbarManager, onActionClick: evt => this.executeAction(evt.detail), actionsList: this.actionsList, statusResolver: this.statusResolver }, h("slot", { name: "SnkGridHeader" }), h("slot", { name: "SnkGridFooter" }), h("slot", { name: "SnkGridTaskBar" }))), h("stack-item", null, h("snk-form", { configName: this.configName, actionsList: this.actionsList, onExit: () => this._viewStack.show(GRID_MODE), recordsValidator: this.recordsValidator, taskbarManager: this.taskbarManager, onActionClick: evt => this.executeAction(evt.detail) }, h("slot", { name: "SnkFormTaskBar" })))));
+  }
+  get _element() { return this; }
+  static get style() { return snkCrudCss; }
+}, [6, "snk-crud", {
+    "configName": [1025, "config-name"],
+    "actionsList": [16],
+    "taskbarManager": [16],
+    "recordsValidator": [16],
+    "statusResolver": [8, "status-resolver"],
+    "_dataUnit": [32],
+    "_dataState": [32]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["snk-crud", "snk-filter-bar", "snk-filter-detail", "snk-filter-item", "snk-filter-list", "snk-form", "snk-grid", "snk-taskbar"];
+  components.forEach(tagName => { switch (tagName) {
+    case "snk-crud":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, SnkCrud$1);
+      }
+      break;
+    case "snk-filter-bar":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$8();
+      }
+      break;
+    case "snk-filter-detail":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$7();
+      }
+      break;
+    case "snk-filter-item":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$6();
+      }
+      break;
+    case "snk-filter-list":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$5();
+      }
+      break;
+    case "snk-form":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$4();
+      }
+      break;
+    case "snk-grid":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$3();
+      }
+      break;
+    case "snk-taskbar":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+
+const SnkCrud = SnkCrud$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { SnkCrud, defineCustomElement };

package/dist/components/snk-data-unit.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface SnkDataUnit extends Components.SnkDataUnit, HTMLElement {}
+export const SnkDataUnit: {
+  prototype: SnkDataUnit;
+  new (): SnkDataUnit;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/snk-data-unit.js

@@ -0,0 +1,303 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { a as Action, A as ApplicationContext } from './index2.js';
+import { A as ApplicationUtils, D as DialogType, O as OperationMap } from './SnkMessageBuilder.js';
+
+const snkDataUnitCss = ".sc-snk-data-unit-h{display:flex;flex-direction:column;height:100%}";
+
+const SnkDataUnit$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.dataStateChange = createEvent(this, "dataStateChange", 7);
+    this.dataUnitReady = createEvent(this, "dataUnitReady", 7);
+    this.insertionMode = createEvent(this, "insertionMode", 7);
+    this.cancelEdition = createEvent(this, "cancelEdition", 7);
+    this._onDataUnitResolve = [];
+    /**
+     * Determina quantas linhas são retornadas por página
+     */
+    this.pageSize = 150;
+    /**
+     * Quando ativada essa propriedade faz com que haja uma carga imediata no DataUnit
+     */
+    this.autoLoad = true;
+    this._dataUnitObserver = (action) => {
+      const duState = {
+        insertionMode: false,
+        hasNext: this.dataUnit.hasNext(),
+        hasPrevious: this.dataUnit.hasPrevious(),
+        copyMode: false,
+        isDirty: this.dataUnit.isDirty(),
+        hasDirtyRecords: this.dataUnit.hasDirtyRecords(),
+        selectedRecords: this.dataUnit.getSelectedRecords()
+      };
+      this.dataUnit.records.forEach(r => {
+        if (r.__record__id__.startsWith('NEW_')) {
+          duState.insertionMode = true;
+          duState.copyMode || (duState.copyMode = r['__record__source__id__'] != undefined);
+        }
+      });
+      this.dataState = duState;
+      if (action.type === Action.DATA_SAVED) {
+        const msg = this.getMessage("snkDataUnit.saveInfo", action.payload.records[0]);
+        if (msg != undefined) {
+          this.showSuccessMessage(msg);
+        }
+      }
+      if (action.type === Action.RECORDS_ADDED || action.type === Action.RECORDS_COPIED) {
+        this.insertionMode.emit();
+      }
+      if (action.type === Action.EDITION_CANCELED) {
+        this.cancelEdition.emit();
+        const cancelFinishMsg = this.getMessage("snkDataUnit.cancelInfo");
+        if (cancelFinishMsg != undefined) {
+          this.showSuccessMessage(cancelFinishMsg);
+        }
+      }
+      if (action.type === Action.RECORDS_REMOVED) {
+        const removeFinishMsg = this.getMessage("snkDataUnit.removeInfo", action.payload.cachedRecords[0]);
+        if (removeFinishMsg != undefined) {
+          this.showSuccessMessage(removeFinishMsg);
+        }
+      }
+      this._application.messagesBuilder.currentOperation = this.getMessageOperation();
+    };
+  }
+  observePageSize() {
+    if (this.dataUnit) {
+      this.dataUnit.pageSize = this.pageSize;
+    }
+  }
+  observeDataUnitName(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataUnit = undefined;
+      this.dataUnitName = newValue;
+      this.loadDataUnit();
+    }
+  }
+  observeEntityName(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataUnit = undefined;
+      this.entityName = newValue;
+      this.loadDataUnit();
+    }
+  }
+  observeDataState(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataStateChange.emit(newValue);
+    }
+  }
+  observeDataUnit() {
+    this.dataUnitReady.emit(this.dataUnit);
+  }
+  /**
+   * Pode-se obter o dataUnit através desse método. Outra forma, é ouvir o evento de
+   *
+   * @returns dataUnit
+   */
+  async getDataUnit() {
+    return new Promise((resolve) => {
+      if (this.dataUnit) {
+        resolve(this.dataUnit);
+      }
+      else {
+        this._onDataUnitResolve.push(resolve);
+      }
+    });
+  }
+  async interceptAction(action) {
+    return new Promise(resolve => {
+      switch (action.type) {
+        case Action.RECORDS_ADDED:
+          if (this.isAllowed("INSERT")) {
+            resolve(action);
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenInsert"));
+          }
+          break;
+        case Action.RECORDS_COPIED:
+          if (this.isAllowed("CLONE")) {
+            resolve(action);
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenClone"));
+          }
+          break;
+        case Action.DATA_CHANGED:
+        case Action.CHANGING_DATA:
+          if (this.isAllowed("UPDATE")) {
+            resolve(action);
+          }
+          else {
+            this.dataUnit.cancelEdition();
+            ApplicationUtils.alert(this.getMessage("snkDataUnit.forbidden"), this.getMessage("snkDataUnit.forbiddenUpdate"));
+          }
+          break;
+        case Action.SAVING_DATA:
+          if (this.beforeSave) {
+            const continueAction = this.beforeSave(this.dataUnit);
+            if (continueAction instanceof Promise) {
+              continueAction.then(result => resolve(result ? action : undefined));
+            }
+            else {
+              resolve(continueAction ? action : undefined);
+            }
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.DATA_SAVED:
+          if (this.afterSave) {
+            this.afterSave(this.dataUnit);
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.EDITION_CANCELED:
+          if (this.dataState.hasDirtyRecords) {
+            const cancelConfirmation = this.getMessage("snkDataUnit.cancelConfirmation");
+            if (cancelConfirmation == undefined) {
+              resolve(action);
+            }
+            else {
+              const cancelConfirmationTitle = this.getMessage("snkDataUnit.cancelConfirmationTitle");
+              ApplicationUtils.confirm(cancelConfirmationTitle, cancelConfirmation)
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.REMOVING_RECORDS:
+          if (this.isAllowed("REMOVE")) {
+            const removeConfirmation = this.getMessage("snkDataUnit.removeConfirmation");
+            if (removeConfirmation == undefined) {
+              resolve(action);
+            }
+            else {
+              const removeConfirmationTitle = this.getMessage("snkDataUnit.removeConfirmationTitle");
+              ApplicationUtils.confirm(removeConfirmationTitle, removeConfirmation, "delete", DialogType.CRITICAL, { btnConfirmDanger: true })
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenRemove"));
+          }
+          break;
+        default:
+          resolve(action);
+      }
+    });
+  }
+  showSuccessMessage(message) {
+    ApplicationUtils.info(message, { iconName: "check" });
+  }
+  isAllowed(flag) {
+    return this._permissions ? this._permissions.isSup || this._permissions[flag] : false;
+  }
+  /**
+   * Conforme mecanismo de mensagens, é possível customizar as mensagens dos blocos de construção
+   * através de um pequeno modulo na estrutura da aplicação:
+   * - Criar um arquivo no seguinte caminho: /messages/appmessages.msg.js.
+   * Para conhecer os detalhes do módulo, vide o arquivo neste projeto "/src/lib/message/resources/snk-data-unit.msg.ts"
+   */
+  getMessage(key, params = undefined) {
+    if (!params) {
+      params = this.getMessageParams();
+    }
+    return this._application.messagesBuilder.getMessage(key, params);
+  }
+  getMessageParams() {
+    //TODO: Atualmente ainda não usamos o recurso de multiseleção do dataunit, mas no futuro
+    //precisaremos criar um mecanismo para oferecer todos os registros selecionados para a 
+    //mensagem
+    return this.dataState.selectedRecords ? this.dataState.selectedRecords[0] : undefined;
+  }
+  getMessageOperation() {
+    if (this.dataState.copyMode) {
+      return OperationMap.CLONE;
+    }
+    if (this.dataState.insertionMode) {
+      return OperationMap.INSERT;
+    }
+    if (this.dataState.isDirty) {
+      return OperationMap.UPDATE;
+    }
+    return OperationMap.CLEAN;
+  }
+  async loadDataUnit() {
+    if (!this.dataUnit) {
+      if (this._application && this.entityName) {
+        const cacheName = this.dataUnitName ? this.dataUnitName : this.entityName;
+        this.dataUnit = await this._application.getDataUnit(this.entityName, cacheName);
+        this.dataUnit.pageSize = this.pageSize;
+        this.dataUnit.unsubscribe(this._dataUnitObserver);
+        this.dataUnit.addInterceptor(this);
+        this.dataUnit.subscribe(this._dataUnitObserver);
+        let resolver;
+        while (resolver = this._onDataUnitResolve.pop()) {
+          resolver(this.dataUnit);
+        }
+        if (this.autoLoad) {
+          setTimeout(() => {
+            this.dataUnit.loadData();
+          }, 500); //TODO: Ajustar para aguardar filterProvider do dataunit estar pronto.
+        }
+      }
+    }
+  }
+  //---------------------------------------------
+  // Lifecycle web component
+  //---------------------------------------------
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._application.getAllAccess().then(access => this._permissions = access);
+  }
+  componentDidLoad() {
+    this.loadDataUnit();
+  }
+  render() {
+    return (h(Host, null));
+  }
+  get element() { return this; }
+  static get watchers() { return {
+    "pageSize": ["observePageSize"],
+    "dataUnitName": ["observeDataUnitName"],
+    "entityName": ["observeEntityName"],
+    "dataState": ["observeDataState"],
+    "dataUnit": ["observeDataUnit"]
+  }; }
+  static get style() { return snkDataUnitCss; }
+}, [2, "snk-data-unit", {
+    "dataState": [1040],
+    "dataUnitName": [1, "data-unit-name"],
+    "entityName": [1, "entity-name"],
+    "pageSize": [2, "page-size"],
+    "dataUnit": [1040],
+    "beforeSave": [16],
+    "afterSave": [16],
+    "autoLoad": [4, "auto-load"],
+    "getDataUnit": [64]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["snk-data-unit"];
+  components.forEach(tagName => { switch (tagName) {
+    case "snk-data-unit":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, SnkDataUnit$1);
+      }
+      break;
+  } });
+}
+
+const SnkDataUnit = SnkDataUnit$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { SnkDataUnit, defineCustomElement };

package/dist/components/snk-filter-bar.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface SnkFilterBar extends Components.SnkFilterBar, HTMLElement {}
+export const SnkFilterBar: {
+  prototype: SnkFilterBar;
+  new (): SnkFilterBar;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/snk-filter-bar.js

@@ -0,0 +1,6 @@
+import { S as SnkFilterBar$1, d as defineCustomElement$1 } from './snk-filter-bar2.js';
+
+const SnkFilterBar = SnkFilterBar$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { SnkFilterBar, defineCustomElement };