@sankhyalabs/sankhyablocks 1.3.34 → 1.4.0-beta.1

package/dist/cjs/snk-crud.cjs.entry.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-b0b676c5.js');
+const index$1 = require('./index-02201bc9.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 = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.actionClick = index.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 = index$1.ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      this.configName = application.configName;
+    }
+  }
+  render() {
+    return (index.h("ez-view-stack", { ref: (ref) => this._viewStack = ref }, index.h("stack-item", null, index.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 }, index.h("slot", { name: "SnkGridHeader" }), index.h("slot", { name: "SnkGridFooter" }), index.h("slot", { name: "SnkGridTaskBar" }))), index.h("stack-item", null, index.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) }, index.h("slot", { name: "SnkFormTaskBar" })))));
+  }
+  get _element() { return index.getElement(this); }
+};
+SnkCrud.style = snkCrudCss;
+
+exports.snk_crud = SnkCrud;

package/dist/cjs/snk-data-unit.cjs.entry.js

@@ -0,0 +1,280 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-b0b676c5.js');
+const index$1 = require('./index-02201bc9.js');
+const SnkMessageBuilder = require('./SnkMessageBuilder-7717f1e4.js');
+
+const snkDataUnitCss = ".sc-snk-data-unit-h{display:flex;flex-direction:column;height:100%}";
+
+const SnkDataUnit = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.dataStateChange = index.createEvent(this, "dataStateChange", 7);
+    this.dataUnitReady = index.createEvent(this, "dataUnitReady", 7);
+    this.insertionMode = index.createEvent(this, "insertionMode", 7);
+    this.cancelEdition = index.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 === index$1.Action.DATA_SAVED) {
+        const msg = this.getMessage("snkDataUnit.saveInfo", action.payload.records[0]);
+        if (msg != undefined) {
+          this.showSuccessMessage(msg);
+        }
+      }
+      if (action.type === index$1.Action.RECORDS_ADDED || action.type === index$1.Action.RECORDS_COPIED) {
+        this.insertionMode.emit();
+      }
+      if (action.type === index$1.Action.EDITION_CANCELED) {
+        this.cancelEdition.emit();
+        const cancelFinishMsg = this.getMessage("snkDataUnit.cancelInfo");
+        if (cancelFinishMsg != undefined) {
+          this.showSuccessMessage(cancelFinishMsg);
+        }
+      }
+      if (action.type === index$1.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 index$1.Action.RECORDS_ADDED:
+          if (this.isAllowed("INSERT")) {
+            resolve(action);
+          }
+          else {
+            SnkMessageBuilder.ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenInsert"));
+          }
+          break;
+        case index$1.Action.RECORDS_COPIED:
+          if (this.isAllowed("CLONE")) {
+            resolve(action);
+          }
+          else {
+            SnkMessageBuilder.ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenClone"));
+          }
+          break;
+        case index$1.Action.DATA_CHANGED:
+        case index$1.Action.CHANGING_DATA:
+          if (this.isAllowed("UPDATE")) {
+            resolve(action);
+          }
+          else {
+            this.dataUnit.cancelEdition();
+            SnkMessageBuilder.ApplicationUtils.alert(this.getMessage("snkDataUnit.forbidden"), this.getMessage("snkDataUnit.forbiddenUpdate"));
+          }
+          break;
+        case index$1.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 index$1.Action.DATA_SAVED:
+          if (this.afterSave) {
+            this.afterSave(this.dataUnit);
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case index$1.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");
+              SnkMessageBuilder.ApplicationUtils.confirm(cancelConfirmationTitle, cancelConfirmation)
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case index$1.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");
+              SnkMessageBuilder.ApplicationUtils.confirm(removeConfirmationTitle, removeConfirmation, "delete", SnkMessageBuilder.DialogType.CRITICAL, { btnConfirmDanger: true })
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            SnkMessageBuilder.ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenRemove"));
+          }
+          break;
+        default:
+          resolve(action);
+      }
+    });
+  }
+  showSuccessMessage(message) {
+    SnkMessageBuilder.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 SnkMessageBuilder.OperationMap.CLONE;
+    }
+    if (this.dataState.insertionMode) {
+      return SnkMessageBuilder.OperationMap.INSERT;
+    }
+    if (this.dataState.isDirty) {
+      return SnkMessageBuilder.OperationMap.UPDATE;
+    }
+    return SnkMessageBuilder.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 = index$1.ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._application.getAllAccess().then(access => this._permissions = access);
+  }
+  componentDidLoad() {
+    this.loadDataUnit();
+  }
+  render() {
+    return (index.h(index.Host, null));
+  }
+  get element() { return index.getElement(this); }
+  static get watchers() { return {
+    "pageSize": ["observePageSize"],
+    "dataUnitName": ["observeDataUnitName"],
+    "entityName": ["observeEntityName"],
+    "dataState": ["observeDataState"],
+    "dataUnit": ["observeDataUnit"]
+  }; }
+};
+SnkDataUnit.style = snkDataUnitCss;
+
+exports.snk_data_unit = SnkDataUnit;

package/dist/cjs/snk-filter-bar.cjs.entry.js

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-b0b676c5.js');
+const index$1 = require('./index-02201bc9.js');
+const filterItemType_enum = require('./filter-item-type.enum-e2e1bc5b.js');
+
+const snkFilterBarCss = ".sc-snk-filter-bar-h{display:grid;grid-template-columns:minmax(100px, 100%) 1fr 1fr}.snk-filter__popover-container.sc-snk-filter-bar{display:flex;cursor:auto}.snk-filter__popover.sc-snk-filter-bar{display:flex;flex-direction:column;position:absolute;width:fit-content;height:fit-content;min-width:265px;z-index:var(--more-visible, 1);background-color:var(--background--xlight, #fff);border-radius:var(--border--radius-medium, 12px);box-shadow:var(--shadow, 0px 0px 16px 0px #000)}.snk-filter-item__editor-header.sc-snk-filter-bar{flex-grow:1;font-weight:var(--text-weight--medium, 400);color:var(--color--title-primary, #2B3A54)}.snk-filter__popover-rule.sc-snk-filter-bar{border-style:solid;border-color:var(--color--disable-secondary, #F2F5F8);border-radius:1px;border-width:1px;width:100%}.editor__ez-check.sc-snk-filter-bar{--ez-check__label--padding-left:0}.snk-filter-item__editor-header-button.sc-snk-filter-bar{cursor:pointer;flex-grow:0}.snk-filter-bar__divider.sc-snk-filter-bar{margin-bottom:var(--space--small)}.snk-filter-bar__filter-list-items-container.sc-snk-filter-bar{overflow-y:auto;max-height:360px;margin-top:var(--space--small, 6px)}.snk-filter-bar__filter-list-item.sc-snk-filter-bar{cursor:pointer;border-radius:var(--border--radius-small, 6px)}.snk-filter-bar__filter-list-item__label.sc-snk-filter-bar{color:var(--title--primary)}.snk-filter-bar__filter-list-item__label--secondary.sc-snk-filter-bar{color:var(--text--primary)}.snk-filter-bar__filter-list-item__icon.sc-snk-filter-bar{--ez-icon--color:var(--title--primary)}.snk-filter-bar__filter-list-item__icon--secondary.sc-snk-filter-bar{--ez-icon--color:var(--text--secondary)}.snk-filter-bar__filter-list-item.preselected.sc-snk-filter-bar{background-color:var(--background--medium)}.snk-filter-bar__filter-list-item.sc-snk-filter-bar:hover{background-color:var(--background--medium)}.snk-filter-bar__filter-list-items-container--empty.sc-snk-filter-bar{width:100%;height:100px;display:flex;justify-content:center;align-self:center;align-items:center}.snk-filter-bar__filter-list-items-button--active.sc-snk-filter-bar{position:relative}.snk-filter-bar__filter-list-items-button--active.sc-snk-filter-bar::after{display:flex;position:absolute;content:\"\";width:8px;height:8px;top:7px;left:17px;background-color:var(--icon--alert--color, #008561);border-radius:50%}";
+
+const PERSONALIZED_FILTER = "PERSONALIZED_FILTER";
+const DEFAULT_FILTER = "DEFAULT_FILTER";
+const CLEAR_ALL_FILTERS = "CLEAR_ALL_FILTERS";
+const SnkFilterBar = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this._updateSequence = [];
+    this._calculateSortIndex = (item) => {
+      let index = item.hardFixed ? 1000000 : 0;
+      //campos Hard Fixed não variam a ordem
+      if (!item.hardFixed) {
+        index += item.fixed ? 100000 : 0;
+        index += item.value == undefined ? 0 : 10000;
+        index += this._updateSequence.lastIndexOf(item.id) + 1;
+      }
+      return index;
+    };
+    this._filtersComparator = (a, b) => {
+      return this._calculateSortIndex(b) - this._calculateSortIndex(a);
+    };
+  }
+  /**
+   * 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-filter-bar.msg.ts"
+   */
+  getMessage(key, params) {
+    return this._application.messagesBuilder.getMessage(key, params);
+  }
+  getFilter(_dataUnit) {
+    var _a;
+    const filters = [];
+    (_a = this.filterConfig) === null || _a === void 0 ? void 0 : _a.filter(item => item.value).forEach(item => {
+      const filter = this.buildDUFilter(item);
+      if (filter) {
+        filters.push(filter);
+      }
+    });
+    return filters;
+  }
+  buildDUFilter(item) {
+    const { id, value, type, props, visible } = item;
+    if (value && visible) {
+      if (type === filterItemType_enum.FilterItemType.BINARY_SELECT) {
+        const options = props.options;
+        const selectedOption = options.find(opt => opt.name === value);
+        //FIXME: ajustar o backend para não exigir parametros
+        return { name: id, expression: selectedOption.expression, params: [] };
+      }
+      if (type === filterItemType_enum.FilterItemType.MULTI_SELECT) {
+        return { name: id, expression: props.expression, params: [{ name: id, dataType: index$1.DataType.TEXT, value }] };
+      }
+      if (type === filterItemType_enum.FilterItemType.PERIOD) {
+        let { end, start } = value;
+        if (typeof end === "string") {
+          end = new Date(end);
+        }
+        if (typeof start === "string") {
+          start = new Date(start);
+        }
+        const params = [];
+        let expression;
+        if (end && start) {
+          expression = props.expression.fullfill;
+          params.push({ name: `${id}.START`, dataType: index$1.DataType.DATE, value: index$1.toString(index$1.DataType.DATE, start) }, { name: `${id}.END`, dataType: index$1.DataType.DATE, value: index$1.toString(index$1.DataType.DATE, end) });
+        }
+        else {
+          if (start) {
+            expression = props.expression.onlystart;
+            params.push({ name: id, dataType: index$1.DataType.DATE, value: index$1.toString(index$1.DataType.DATE, start) });
+          }
+          else {
+            expression = props.expression.onlyend;
+            params.push({ name: id, dataType: index$1.DataType.DATE, value: index$1.toString(index$1.DataType.DATE, end) });
+          }
+        }
+        return { name: id, expression, params };
+      }
+      if (type === filterItemType_enum.FilterItemType.SEARCH) {
+        const expression = props.expression;
+        return { name: id, expression, params: [{ name: id, dataType: index$1.DataType.TEXT, value: index$1.toString(index$1.DataType.TEXT, value.value) }] };
+      }
+      if (type === filterItemType_enum.FilterItemType.TEXT) {
+        const expression = props.expression;
+        return { name: id, expression, params: [{ name: id, dataType: index$1.DataType.TEXT, value: index$1.toString(index$1.DataType.TEXT, value) }] };
+      }
+      if (type === filterItemType_enum.FilterItemType.NUMBER) {
+        const expression = props.expression;
+        return { name: id, expression, params: [{ name: id, dataType: index$1.DataType.NUMBER, value: index$1.toString(index$1.DataType.NUMBER, value) }] };
+      }
+      //No mapeamento dos outros tipos precisamos saber o tipo de dado.
+    }
+    return undefined;
+  }
+  componentWillLoad() {
+    this._application = index$1.ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    if (this._application) {
+      this._application.getFilterBarConfig(this.configName)
+        .then((filters) => {
+        this.filterConfig = filters;
+      })
+        .catch(reason => {
+        throw new index$1.ErrorException(this.getMessage("snkFilterBar.failToLoadConfig"), reason);
+      });
+    }
+    if (this.dataUnit == undefined) {
+      let parent = this._element.parentElement;
+      while (parent) {
+        if (parent.tagName.toUpperCase() === "SNK-DATA-UNIT") {
+          const snkDataUnit = parent;
+          this.dataUnit = snkDataUnit.dataUnit;
+          if (this.dataUnit) {
+            this.dataUnit.addFilterProvider(this);
+          }
+          else {
+            snkDataUnit.addEventListener("dataUnitReady", (evt) => {
+              this.dataUnit = evt.detail;
+              this.dataUnit.addFilterProvider(this);
+            });
+          }
+          break;
+        }
+      }
+      parent = parent.parentElement;
+    }
+    else {
+      this.dataUnit.addFilterProvider(this);
+    }
+  }
+  getFilterItems() {
+    const pinnedItems = [];
+    const unpinnedItems = [];
+    this.filterConfig
+      .filter(item => item.visible)
+      .sort((a, b) => this._filtersComparator(a, b))
+      .forEach((item, index$1) => {
+      const filterItem = (index.h("snk-filter-item", { id: `filter-${item.id}`, config: this.normalizeItem(item), class: index$1 > 0 ? "ez-padding-left--medium" : "", getMessage: (key, props) => this.getMessage(key, props), key: item.id }));
+      if (item.fixed || item.hardFixed) {
+        pinnedItems.push(filterItem);
+      }
+      else {
+        unpinnedItems.push(filterItem);
+      }
+      return filterItem;
+    });
+    const elements = [];
+    elements.push(...pinnedItems);
+    if (pinnedItems.length > 0 && unpinnedItems.length > 0) {
+      elements.push(index.h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-left--medium snk-filter-bar__divider" }));
+    }
+    elements.push(...unpinnedItems);
+    return elements;
+  }
+  calculateUpdateSequence(item) {
+    if (item) {
+      this._updateSequence = this._updateSequence.filter(itemId => item.id !== itemId);
+      this._updateSequence.push(item.id);
+    }
+  }
+  filterChangeListener(evt) {
+    this.updateFilter(evt.detail);
+  }
+  normalizeItem(item) {
+    const normalized = Object.assign({}, item);
+    const optionals = ["props", "value", "hardFixed", "fixed"];
+    optionals.forEach(prop => {
+      if (normalized[prop] == undefined) {
+        delete normalized[prop];
+      }
+    });
+    if (item.value === "") {
+      delete item.value;
+    }
+    return normalized;
+  }
+  updateFilter(newItem, clear = false) {
+    let needLoad = false;
+    let updated = false;
+    this.filterConfig = this.filterConfig.map(item => {
+      if (clear) {
+        if (item.value != undefined) {
+          updated = true;
+          needLoad = true;
+        }
+        return Object.assign(Object.assign({}, item), { value: undefined });
+      }
+      else {
+        if (item.id === newItem.id) {
+          const normalizedOne = this.normalizeItem(item);
+          const normalizedTwo = this.normalizeItem(newItem);
+          updated = index$1.ObjectUtils.objectToString(normalizedOne) != index$1.ObjectUtils.objectToString(normalizedTwo);
+          needLoad = index$1.ObjectUtils.objectToString(normalizedOne.value) !== index$1.ObjectUtils.objectToString(normalizedTwo.value);
+          return newItem;
+        }
+      }
+      return item;
+    });
+    if (needLoad) {
+      this.dataUnit.loadData();
+    }
+    if (updated) {
+      this.calculateUpdateSequence(newItem);
+      this._application.saveFilterBarConfig(this.filterConfig, this.configName);
+    }
+    return needLoad;
+  }
+  getAddListItems() {
+    const hiddenItems = this.filterConfig
+      .filter(item => !item.visible)
+      .sort(this._filtersComparator);
+    return hiddenItems.map(filter => {
+      return { name: filter.id, label: filter.label, kind: "FILTER", iconName: null };
+    }).concat([
+      { name: PERSONALIZED_FILTER, label: this.getMessage("snkFilterBar.customFilter"), iconName: "tune", kind: "FOOTER" },
+      { name: DEFAULT_FILTER, label: this.getMessage("snkFilterBar.defaultFilter"), iconName: "configuration", kind: "FOOTER" }
+    ]);
+  }
+  getActiveClass() {
+    const filterApplied = this.filterConfig.filter(item => item.value != undefined).length > 0;
+    return filterApplied ? "sc-snk-filter-bar snk-filter-bar__filter-list-items-button--active" : "";
+  }
+  getAppliedListItems() {
+    const appliedItems = this.filterConfig
+      .filter(item => item.value != undefined)
+      .sort(this._filtersComparator);
+    return appliedItems.map(filter => {
+      return { name: filter.id, label: filter.label, kind: "FILTER", iconName: null };
+    }).concat([
+      { name: CLEAR_ALL_FILTERS, label: this.getMessage("snkFilterBar.clearAllFilters"), iconName: "cleaning", kind: "FOOTER" }
+    ]);
+  }
+  addFilterHandler(itemName) {
+    const filterItem = this.filterConfig.find(currentFilter => currentFilter.id === itemName);
+    if (filterItem) {
+      this.updateFilter(Object.assign(Object.assign({}, filterItem), { visible: true }));
+      window.requestAnimationFrame(() => {
+        const itemElement = this._element.querySelector("#filter-" + itemName);
+        if (itemElement) {
+          itemElement.showUp();
+        }
+      });
+    }
+  }
+  appliedFilterHandler(itemName) {
+    if (itemName === CLEAR_ALL_FILTERS) {
+      if (this.updateFilter(null, true)) {
+        this._application.info(this.getMessage("snkFilterBar.successfullyCleaned"), { iconName: "check" });
+      }
+    }
+    else {
+      const itemElement = this._element.querySelector("#filter-" + itemName);
+      if (itemElement) {
+        itemElement.showUp(true);
+      }
+    }
+  }
+  render() {
+    if (!this.dataUnit || !this.filterConfig || this.filterConfig.length === 0) {
+      return undefined;
+    }
+    return (index.h(index.Host, null, index.h("ez-scroller", { direction: "horizontal" }, this.getFilterItems()), index.h("snk-filter-list", { items: this.getAppliedListItems(), getMessage: (key, params) => this.getMessage(key, params), emptyText: this.getMessage("snkFilterBar.emptyAppliedFiltersList"), findFilterText: this.getMessage("snkFilterBar.findFilter"), iconName: "filter", class: "ez-padding-left--medium", buttonClass: this.getActiveClass(), onSnkItemSelected: evt => this.appliedFilterHandler(evt.detail) }), index.h("snk-filter-list", { items: this.getAddListItems(), label: this.getMessage("snkFilterBar.addFilter"), getMessage: (key, params) => this.getMessage(key, params), emptyText: this.getMessage("snkFilterBar.emptyFiltersList"), findFilterText: this.getMessage("snkFilterBar.findField"), class: "ez-padding-left--medium", onSnkItemSelected: evt => this.addFilterHandler(evt.detail) }, index.h("ez-icon", { slot: "leftIcon", class: "ez-padding-right--small", iconName: "plus" }))));
+  }
+  get _element() { return index.getElement(this); }
+};
+SnkFilterBar.style = snkFilterBarCss;
+
+exports.snk_filter_bar = SnkFilterBar;

package/dist/cjs/snk-filter-binary-select.cjs.entry.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-b0b676c5.js');
+const filterItemType_enum = require('./filter-item-type.enum-e2e1bc5b.js');
+
+const SnkFilterBinarySelect = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+  }
+  isSelected(option) {
+    return this.value == undefined || this.value === option;
+  }
+  ezChangeListener(evt) {
+    if (!evt.detail) {
+      this.assertCheckedOption(evt.target);
+    }
+    this.updateValue();
+  }
+  assertCheckedOption(updatingCheck) {
+    if (updatingCheck === this._checkOne) {
+      this._checkTwo.value = true;
+    }
+    else {
+      this._checkOne.value = true;
+    }
+  }
+  updateValue() {
+    if (!this._checkOne.value || !this._checkTwo.value) {
+      const [optOne, optTwo] = this.config.props.options;
+      this.value = this._checkOne.value ? optOne.name : optTwo.name;
+    }
+    else {
+      this.value = undefined;
+    }
+  }
+  render() {
+    if (!this.config || this.config.type !== filterItemType_enum.FilterItemType.BINARY_SELECT) {
+      return undefined;
+    }
+    const [optOne, optTwo] = this.config.props.options;
+    return (index.h(index.Host, null, index.h("ez-check", { label: optOne.label, class: "sc-snk-filter-bar editor__ez-check", ref: (ref) => this._checkOne = ref, value: this.isSelected(optOne.name) }), index.h("ez-check", { label: optTwo.label, class: "sc-snk-filter-bar editor__ez-check", ref: (ref) => this._checkTwo = ref, value: this.isSelected(optTwo.name) })));
+  }
+};
+
+exports.snk_filter_binary_select = SnkFilterBinarySelect;