@sankhyalabs/sankhyablocks 0.0.0-feat-dev-kb-4158.0

package/dist/collection/components/snk-filter-bar/snk-filter-bar.css

@@ -0,0 +1,184 @@
+:host {
+  display: grid;
+  grid-template-columns: minmax(100px, 100%) 1fr 1fr;
+
+   /*@doc Define o z-index do componente.*/
+   --snk-personalized-filter--z-index: var(--most-visible, 3);
+   /*@doc Define a cor de fundo do componente.*/
+   --snk-personalized-filter--background-color: var(--background--xlight, #fff);
+}
+
+.snk-filter__popover-container{
+  /*private*/
+  display: flex;
+  cursor: auto;
+}
+
+.filter-bar__personalized-filter{
+    /*private*/
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    overflow: auto;
+  
+    /*public*/
+    z-index: var(--snk-personalized-filter--z-index);
+    background-color: var(--snk-personalized-filter--background-color);
+}
+
+.snk-filter__popover{
+  /*private*/
+  display: flex;
+  flex-direction: column;
+  position: absolute;
+  width: fit-content;
+  height: fit-content;
+  min-width: 265px;
+  
+  /*public*/
+  z-index: var(--most-visible, 3);
+  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{
+  flex-grow: 1;
+  font-weight: var(--text-weight--medium, 400);
+  color: var(--color--title-primary, #2B3A54);
+}
+
+.snk-filter__popover-rule{
+  border-style: solid;
+  border-color: var(--color--disable-secondary, #F2F5F8);
+  border-radius: 1px;
+  border-width: 1px;
+  width: 100%;
+}
+
+.editor__ez-check{
+  --ez-check__label--padding-left: 0;
+}
+
+.snk-filter-item__editor-header-button{
+  cursor: pointer;
+  background-color: transparent;
+  border: none;
+  padding: 3px;
+  outline-color: var(--color--primary);
+}
+
+.snk-filter-bar__divider{
+  margin-bottom: var(--space--small);
+}
+
+.snk-filter-bar__scroller {
+  height: calc(100% + var(--space-extra-small, 3px));
+}
+
+.snk-filter-bar__filter-item-container {
+  display: flex;
+  align-self: center;
+}
+
+.snk-filter-bar__scroller :first-child {
+  margin-left: var(--space-extra-small, 3px);
+}
+
+
+.snk-filter-bar__filter-list-items-container{
+  overflow-y: auto;
+  max-height: 360px;
+  margin-top: var(--space--small, 6px);
+}
+
+.snk-filter-bar__filter-list-item{
+  cursor: pointer;
+  border-radius: var(--border--radius-small, 6px);
+  border: none;
+  background-color: transparent;
+}
+
+.snk-filter-bar__filter-list-item__label{
+  color: var(--title--primary);
+}
+
+.snk-filter-bar__filter-list-item__label--secondary{
+  color: var(--text--primary);
+}
+
+.snk-filter-bar__filter-list-item__icon{
+  --ez-icon--color: var(--title--primary);
+}
+
+.snk-filter-bar__filter-list-item__icon--secondary{
+  --ez-icon--color: var(--text--secondary);
+}
+
+.snk-filter-bar__filter-list-item:focus-visible {
+  outline: none;
+  background-color: var(--background--medium);
+}
+
+.snk-filter-bar__filter-list-item:hover{
+  background-color: var(--background--medium);
+}
+
+.snk-filter-bar__filter-list-items-container--empty{
+  width: 100%;
+  height: 100px;
+  display: flex;
+  justify-content: center;
+  align-self: center;
+  align-items: center;
+}
+
+.snk-filter-bar__filter-list-items-button--active{
+  position: relative;
+}
+.snk-filter-bar__filter-list-items-button--active::after{
+  display: flex;
+  position: absolute;
+  content: "";
+  width: 8px;
+  height: 8px;
+  top: 7px;
+  left: 17px;
+  background-color: var(--icon--alert--color, #008561);
+  border-radius: 50%;
+}
+
+.snk-filter-bar__filter-modal-item{
+  --modal-item-border-width: 2px;
+  display: flex;
+  flex-direction: row;
+  margin-left: var(--modal-item-border-width);
+  border-radius: var(--border--radius-medium, 12px);
+  background-color: var(--background--medium, #f0f3f7);
+  border: none;
+  width: 100%;
+  
+}
+
+.snk-filter-bar__filter-modal-item:focus-visible{
+  outline: var(--color--primary) solid var(--modal-item-border-width);
+}
+
+.snk-filter-bar__filter-modal-item__check{
+  width: auto;
+}
+.snk-filter-bar__filter-modal-item__label{
+  font-weight: var(--text-weight--medium);
+}
+
+.snk-filter-bar__filter-modal-content{
+  display: grid;
+  grid-template-rows: auto auto 1fr auto;
+  width: 99%;
+  height: 100%;
+}

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

@@ -0,0 +1,463 @@
+import { ApplicationContext, ElementIDUtils, ErrorException, ObjectUtils } from '@sankhyalabs/core';
+import { EzScrollDirection } from '@sankhyalabs/ezui/dist/collection/components/ez-scroller/EzScrollDirection';
+import { h, Host } from '@stencil/core';
+import { ConfigStorage } from '../../lib/configs/ConfigStorage';
+import buildFilter from './filter-item/dataunitfilter/data-unit-filter-builder';
+import FilterItemType from './filter-item/filter-item-type.enum';
+import SnkFilterModalFactory from './utils/SnkFilterModalFactory';
+import { PersonalizedFilterUtils } from '../snk-personalized-filter/subcomponents/snk-filter-param-config/utils/PersonalizedFilterUtils';
+export class SnkFilterBar {
+  constructor() {
+    this._updateSequence = [];
+    this._loadingPending = false;
+    this._configUpdated = false;
+    this._pendingVariables = false;
+    this._customfiltersToBeUpdated = [];
+    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);
+    };
+    this.dataUnit = undefined;
+    this.configName = undefined;
+    this.filterConfig = undefined;
+    this.messagesBuilder = undefined;
+    this.allowDefault = undefined;
+    this.scrollerLocked = false;
+    this.showPersonalizedFilter = false;
+    this.personalizedFilterId = undefined;
+  }
+  observeFilterConfig(newValue, oldValue) {
+    if (oldValue != undefined && newValue == undefined) {
+      this._loadingPending = true;
+      this._configUpdated = true;
+    }
+    else {
+      const oldItems = new Map(oldValue ? oldValue.map(item => [item.id, item]) : undefined);
+      if (oldItems.size === 0 && newValue.length > 0) {
+        this._loadingPending = true;
+        this._configUpdated = false;
+      }
+      else {
+        newValue.forEach(newItem => {
+          const oldItem = oldItems.get(newItem.id);
+          if (oldItem != undefined) {
+            this._configUpdated = this._configUpdated || ObjectUtils.objectToString(oldItem) != ObjectUtils.objectToString(newItem);
+            this._loadingPending = this._loadingPending || ObjectUtils.objectToString(oldItem.value) !== ObjectUtils.objectToString(newItem.value);
+            if (!this._loadingPending) {
+              const groupedChanged = ObjectUtils.objectToString(oldItem.groupedItems) != ObjectUtils.objectToString(newItem.groupedItems);
+              this._configUpdated = this._configUpdated || groupedChanged;
+              this._loadingPending = this._loadingPending || groupedChanged;
+            }
+          }
+          else {
+            this._configUpdated = true;
+            this._loadingPending = this._loadingPending || newItem.value != undefined;
+          }
+        });
+      }
+    }
+    this.processAfterUpdateConfig();
+  }
+  /**
+   * Faz o recarregamento da filterbar buscando o state no servidor.
+   */
+  async reload() {
+    this.loadConfigFromStorage();
+  }
+  componentDidLoad() {
+    if (this._element) {
+      const dataInfo = { dataUnit: this.dataUnit };
+      ElementIDUtils.addIDInfo(this._element, null, dataInfo);
+    }
+  }
+  processPendingFilter() {
+    if (this._pendingVariables) {
+      const popUp = this._element.querySelector("#filter-PERSONALIZED_FILTER_GROUP");
+      if (popUp) {
+        popUp.showUp(true).then(() => {
+          this.processAfterUpdateConfig();
+        });
+      }
+    }
+    else {
+      this.processAfterUpdateConfig();
+    }
+  }
+  getPersonalizedFilterItem() {
+    return this.filterConfig.find(item => item.type === FilterItemType.PERSONALIZED);
+  }
+  async processAfterUpdateConfig() {
+    if (this._loadingPending) {
+      const personalizedFilter = this.getPersonalizedFilterItem();
+      this._pendingVariables = !PersonalizedFilterUtils.validateVariableValues(personalizedFilter);
+      if (this._pendingVariables) {
+        return;
+      }
+      this._loadingPending = false;
+      this.dataUnit.loadData();
+    }
+    if (this._configUpdated) {
+      this._configUpdated = false;
+      ConfigStorage.saveFilterBarConfig(this.filterConfig, this.configName);
+    }
+  }
+  /**
+   * 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, defaultValue) {
+    var _a;
+    return ((_a = this.messagesBuilder) === null || _a === void 0 ? void 0 : _a.getMessage(key, params)) || defaultValue;
+  }
+  getFilter(_dataUnit) {
+    var _a;
+    const filters = [];
+    (_a = this.filterConfig) === null || _a === void 0 ? void 0 : _a.filter(item => this.isActiveFilter(item)).forEach(item => {
+      const filter = buildFilter(item);
+      if (filter) {
+        filters.push(filter);
+      }
+    });
+    return filters;
+  }
+  isActiveFilter(item) {
+    /*
+      - O filtro padrão também deve sempre ser condiderado ativo, pois, sempre deve
+        ser aplicado.
+    */
+    if (item.type === FilterItemType.DEFAULT_FILTER) {
+      return true;
+    }
+    return this.filterActiveFilter(item) && (item.groupedItems || item.value != undefined);
+  }
+  registryFilterProvider() {
+    this.dataUnit.addFilterProvider(this);
+    if (this.filterConfig) {
+      this.dataUnit.loadData();
+    }
+  }
+  itemFocused(selectedItem) {
+    this._element.querySelectorAll("snk-filter-item,snk-filter-list").forEach(item => {
+      if (item.id === selectedItem) {
+        if (item.tagName.toLowerCase() === "snk-filter-item" && item.getClientRects()[0].x < 0) {
+          item.scrollIntoView({ behavior: "auto", inline: 'nearest' });
+        }
+      }
+      else {
+        item["hideDetail"]();
+      }
+    });
+  }
+  filterActiveFilter(item) {
+    return item.visible || item.removalBlocked;
+  }
+  getFilterItems() {
+    const pinnedItems = [];
+    const unpinnedItems = [];
+    this.filterConfig
+      .filter(this.filterActiveFilter)
+      .forEach((item, index) => {
+      item = ObjectUtils.copy(item);
+      const itemId = `filter-${item.id}`;
+      const filterItem = (h("snk-filter-item", { onVisibleChanged: (evt) => this.scrollerLocked = evt.detail, onFilterChange: (event) => this.updateFilter(event.detail), onFocusin: () => this.itemFocused(itemId), id: itemId, config: item, class: index > 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(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);
+    }
+  }
+  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) {
+    this.filterConfig = this.filterConfig.map(item => {
+      newItem = this.normalizeItem(newItem);
+      if (item.id === newItem.id) {
+        if (ObjectUtils.objectToString(item) != ObjectUtils.objectToString(newItem)) {
+          this.calculateUpdateSequence(newItem);
+        }
+        return newItem;
+      }
+      return item;
+    }).sort((a, b) => this._filtersComparator(a, b));
+  }
+  loadPermitions() {
+    this._application.isUserSup().then(value => this.allowDefault = value);
+  }
+  loadConfigFromStorage() {
+    return new Promise(accept => {
+      ConfigStorage.get().then(instance => {
+        instance.loadFilterBarConfig(this.configName, { contextURI: this.dataUnit.name })
+          .then((filters) => {
+          accept();
+          this.filterConfig = filters.map(item => this.normalizeItem(item));
+        })
+          .catch(reason => {
+          throw new ErrorException(this.getMessage("snkFilterBar.failToLoadConfig"), reason);
+        });
+      });
+    });
+  }
+  attachDataUnit() {
+    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.registryFilterProvider();
+          }
+          else {
+            snkDataUnit.addEventListener("dataUnitReady", (evt) => {
+              this.dataUnit = evt.detail;
+              this.registryFilterProvider();
+            });
+          }
+          break;
+        }
+      }
+      parent = parent.parentElement;
+    }
+    else {
+      this.registryFilterProvider();
+    }
+  }
+  /**
+  * Emitido quando acontece a alteração do estado do filtro.
+  */
+  filterChangeListener(evt) {
+    this.updateFilter(evt.detail);
+  }
+  async showFilterModal() {
+    const callbackOnApplyFilter = (filters) => {
+      this.filterConfig = filters.map(this.normalizeItem).sort((a, b) => this._filtersComparator(a, b));
+    };
+    const factoryParams = {
+      filterConfig: ObjectUtils.copy(this.filterConfig),
+      configName: this.configName,
+      onComplete: callbackOnApplyFilter,
+      getMessage: (key, props) => this.getMessage(key, props),
+      onAddPersonalizedFilter: () => this.addPersonalizedFilter(),
+      onEditPersonalizedFilter: (id) => this.editPersonalizedFilter(id)
+    };
+    this._filterModalFactory = new SnkFilterModalFactory(factoryParams);
+    await this._filterModalFactory.showModal();
+  }
+  addPersonalizedFilter() {
+    this._filterModalFactory.closeModal();
+    this.personalizedFilterId = undefined;
+    this.showPersonalizedFilter = true;
+    window.requestAnimationFrame(() => {
+      this._elPersonalizedFilter.createPersonalizedFilter();
+    });
+  }
+  editPersonalizedFilter(id) {
+    this._filterModalFactory.closeModal();
+    this.showPersonalizedFilter = true;
+    this.personalizedFilterId = id;
+  }
+  hidePersonalizedFilter() {
+    this.loadConfigFromStorage().then(() => {
+      this.personalizedFilterId = undefined;
+      this.showPersonalizedFilter = false;
+    });
+  }
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    if (this._application) {
+      this.loadPermitions();
+      this.loadConfigFromStorage();
+    }
+    this.attachDataUnit();
+  }
+  componentDidRender() {
+    this.processPendingFilter();
+  }
+  render() {
+    if (!this.dataUnit || !this.filterConfig || this.filterConfig.length === 0) {
+      return undefined;
+    }
+    if (this.showPersonalizedFilter) {
+      return h("snk-personalized-filter", { class: "filter-bar__personalized-filter", filterId: this.personalizedFilterId, ref: (el) => this._elPersonalizedFilter = el, onEzCancel: () => this.hidePersonalizedFilter(), entityUri: this.dataUnit.name, configName: this.configName });
+    }
+    return (h(Host, null, h("ez-scroller", { class: "snk-filter-bar__scroller", direction: EzScrollDirection.HORIZONTAL, activeShadow: true, locked: this.scrollerLocked }, h("section", { class: "snk-filter-bar__filter-item-container" }, this.getFilterItems())), h("ez-button", { class: "ez-padding-left--medium", size: "small", label: this.getMessage('snkFilterBar.filters', undefined, 'Filtros'), onClick: this.showFilterModal.bind(this) }, h("ez-icon", { slot: "leftIcon", iconName: "plus", class: "ez-padding-right--small" }))));
+  }
+  static get is() { return "snk-filter-bar"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["snk-filter-bar.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["snk-filter-bar.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "dataUnit": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "DataUnit",
+          "resolved": "DataUnit",
+          "references": {
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Recebe o DataUnit do ambiente. Se n\u00E3o for informado, procura pela refer\u00EAncia\ndo SnkDataUnit. Necess\u00E1rio para se registrar como provedor de filtros."
+        }
+      },
+      "configName": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Eventualmente poderemos ter mais de uma barra de filtros. Essa propriedade\nserve para separar a configura\u00E7\u00E3o de cada uma."
+        },
+        "attribute": "config-name",
+        "reflect": false
+      },
+      "filterConfig": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "Array<SnkFilterItemConfig>",
+          "resolved": "SnkFilterItemConfig[]",
+          "references": {
+            "Array": {
+              "location": "global"
+            },
+            "SnkFilterItemConfig": {
+              "location": "import",
+              "path": "./filter-item/snk-filter-item"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Lista todos os filtros dispon\u00EDveis ao usu\u00E1rio."
+        }
+      },
+      "messagesBuilder": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "SnkMessageBuilder",
+          "resolved": "SnkMessageBuilder",
+          "references": {
+            "SnkMessageBuilder": {
+              "location": "import",
+              "path": "../../lib/message/SnkMessageBuilder"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Respons\u00E1vel por flexibilizar e padronizar o uso de mensagens nos blocos de constru\u00E7\u00E3o."
+        }
+      }
+    };
+  }
+  static get states() {
+    return {
+      "allowDefault": {},
+      "scrollerLocked": {},
+      "showPersonalizedFilter": {},
+      "personalizedFilterId": {}
+    };
+  }
+  static get methods() {
+    return {
+      "reload": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Faz o recarregamento da filterbar buscando o state no servidor.",
+          "tags": []
+        }
+      }
+    };
+  }
+  static get elementRef() { return "_element"; }
+  static get watchers() {
+    return [{
+        "propName": "filterConfig",
+        "methodName": "observeFilterConfig"
+      }];
+  }
+  static get listeners() {
+    return [{
+        "name": "filterChange",
+        "method": "filterChangeListener",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }];
+  }
+}

package/dist/collection/components/snk-filter-bar/types/custom-element-filter.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/snk-filter-bar/types/filter-type.enum.js

@@ -0,0 +1,7 @@
+export var FilterType;
+(function (FilterType) {
+  FilterType["QUICK_FILTER"] = "QUICK_FILTER";
+  FilterType["CUSTOM_FILTER"] = "CUSTOM_FILTER";
+  FilterType["OTHER_FILTERS"] = "OTHER_FILTERS";
+})(FilterType || (FilterType = {}));
+export default FilterType;

package/dist/collection/components/snk-filter-bar/utils/SnkFilterModalFactory.js

@@ -0,0 +1,42 @@
+import { ApplicationUtils } from "@sankhyalabs/ezui/dist/collection/utils";
+class SnkFilterModalFactory {
+  constructor({ filterConfig, configName, onComplete, getMessage, onAddPersonalizedFilter, onEditPersonalizedFilter }) {
+    this._filterConfig = filterConfig;
+    this._configName = configName;
+    this._onComplete = onComplete;
+    this._getMessage = getMessage;
+    this._addPersonalizedFilterFn = onAddPersonalizedFilter;
+    this._editPersonalizedFilterFn = onEditPersonalizedFilter;
+  }
+  applyFilters(newFilterConfig) {
+    this._onComplete(newFilterConfig);
+    this._closeModal();
+  }
+  buildFilterModal() {
+    const filterModal = document.createElement("snk-filter-modal");
+    filterModal.className = "ez-size-height--full";
+    filterModal.filters = this._filterConfig;
+    filterModal.configName = this._configName;
+    filterModal.getMessage = this._getMessage.bind(this);
+    filterModal.applyFilters = this.applyFilters.bind(this);
+    filterModal.closeModal = () => this._closeModal();
+    filterModal.addPersonalizedFilter = () => this._addPersonalizedFilterFn();
+    filterModal.editPersonalizedFilter = (id) => this._editPersonalizedFilterFn(id);
+    return filterModal;
+  }
+  async showModal() {
+    const filterModal = this.buildFilterModal();
+    const modalProps = {
+      content: filterModal,
+      position: 'left',
+      heightMode: 'full',
+      closeOutsideClick: false,
+      useScrimLight: true
+    };
+    this._closeModal = await ApplicationUtils.showModal(modalProps);
+  }
+  async closeModal() {
+    this._closeModal();
+  }
+}
+export default SnkFilterModalFactory;