@sankhyalabs/sankhyablocks 5.19.1 → 6.0.0

package/dist/components/snk-personalized-filter2.js

@@ -0,0 +1,238 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host, Fragment } from '@stencil/core/internal/client';
+import { StringUtils, ObjectUtils, ApplicationContext } from '@sankhyalabs/core';
+import { P as PersonalizedFilterUtils } from './PersonalizedFilterUtils.js';
+import { P as PersonalizedFilterFetcher, C as ConfigStorage } from './ConfigStorage.js';
+import { ApplicationUtils } from '@sankhyalabs/ezui/dist/collection/utils';
+import { F as FilterGroupCondition, d as defineCustomElement$5 } from './snk-expression-group2.js';
+import { s as store } from './index3.js';
+import { d as defineCustomElement$4 } from './snk-expression-item2.js';
+import { d as defineCustomElement$3 } from './snk-filter-field-search2.js';
+import { d as defineCustomElement$2 } from './snk-filter-param-config2.js';
+import { d as defineCustomElement$1 } from './snk-simple-bar2.js';
+
+const snkPersonalizedFilterCss = ".sc-snk-personalized-filter-h{display:flex;height:100%;padding:var(--space--large, 24px);--snk-personalized-filter--width:100%;--snk-personalized-filter--height:100%;--snk-personalized-filter--background-color-line:var(--color--disable-secondary);--snk-personalized-filter--margin-line:var(--border--radius-medium, 12px)}.snk-personalized-filter.sc-snk-personalized-filter{height:var(--snk-personalized-filter--width);width:var(--snk-personalized-filter--height)}.snk-personalized-filter__header-actions.sc-snk-personalized-filter{display:flex;gap:var(--space--medium)}.snk-personalized-filter__group.sc-snk-personalized-filter{flex:1}.snk-personalized-filter__expression-input--line.sc-snk-personalized-filter{width:100%;height:2px;background-color:var(--snk-personalized-filter--background-color-line);margin-top:var(--snk-personalized-filter--margin-line);margin-bottom:var(--snk-personalized-filter--margin-line)}.ez-box__main.sc-snk-personalized-filter{height:90%}";
+
+const SnkPersonalizedFilter = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.ezCancel = createEvent(this, "ezCancel", 7);
+    this.ezSave = createEvent(this, "ezSave", 7);
+    this._personalizedFilterFetcher = new PersonalizedFilterFetcher();
+    this._dataSourceFetcher = {
+      fetchData: async (entity) => {
+        let entityURI = entity === null || entity === void 0 ? void 0 : entity.uri;
+        if (StringUtils.isEmpty(entityURI)) {
+          entityURI = this.entityUri;
+        }
+        return await this._personalizedFilterFetcher.loadFields(entityURI);
+      }
+    };
+    this._filterAssistentMode = true;
+    this._filterAssistent = undefined;
+    this.messagesBuilder = undefined;
+    this.entityUri = undefined;
+    this.filterId = undefined;
+    this.configName = undefined;
+  }
+  /*
+   * Cria um novo filtro se não houver nenhum filtro existente
+   */
+  async createPersonalizedFilter() {
+    const newPersonalizedFilter = {
+      name: "",
+      active: true,
+      expression: "",
+      parameters: [],
+      assistent: {
+        id: StringUtils.generateUUID(),
+        items: [
+          {
+            id: StringUtils.generateUUID(),
+            entityName: "",
+            fieldName: "",
+            description: "",
+            fieldLabel: "Valor",
+            type: undefined,
+            expression: undefined,
+            operand: undefined,
+            paramVariable: false,
+            value: undefined,
+            systemConfig: null,
+            userConfig: null
+          }
+        ],
+        childrenGroups: [],
+        operand: FilterGroupCondition.AND
+      }
+    };
+    this._originalFilterAssistent = ObjectUtils.copy(newPersonalizedFilter);
+    this._filterAssistent = ObjectUtils.copy(newPersonalizedFilter);
+  }
+  loadFilter(newValue, oldValue) {
+    if (newValue == null || oldValue == newValue) {
+      return;
+    }
+    ConfigStorage.get().then((_instance) => {
+      ConfigStorage.loadPersonalizedFilter(newValue, this.configName)
+        .then((resp) => {
+        const personalizedFilter = this.addLabelToItems(resp);
+        this._filterAssistent = personalizedFilter;
+        this._originalFilterAssistent = ObjectUtils.copy(personalizedFilter);
+        this._filterAssistentMode = this._filterAssistent.hasOwnProperty("assistent") && this._filterAssistent.assistent != undefined;
+      });
+    });
+  }
+  componentWillLoad() {
+    var _a;
+    if (store.get(`filterFieldsDataSource.${this.entityUri}`) == undefined) {
+      store.set(`filterFieldsDataSource.${this.entityUri}`, this._dataSourceFetcher);
+    }
+    if (!this.messagesBuilder) {
+      this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      this.messagesBuilder = (_a = this._application) === null || _a === void 0 ? void 0 : _a.messagesBuilder;
+    }
+    this.loadFilter(this.filterId, undefined);
+  }
+  getMessage(key, params) {
+    return this._application.messagesBuilder.getMessage(key, params);
+  }
+  saveFilter() {
+    ConfigStorage.savePersonalizedFilter(this._filterAssistent, this.configName).then((personalizedFilter) => {
+      this._elButtonSave.enabled = false;
+      ApplicationUtils.info(this.getMessage("snkPersonalizedFilter.confirmSave.title", { name: this._filterAssistent.name }), { iconName: "check" });
+      const updatedFilterAssistent = Object.assign(Object.assign({}, personalizedFilter), this._filterAssistent);
+      updatedFilterAssistent.parameters = PersonalizedFilterUtils.buildVariableParameters(this._filterAssistent.assistent);
+      this._originalFilterAssistent = ObjectUtils.copy(updatedFilterAssistent);
+      this._filterAssistent = ObjectUtils.copy(updatedFilterAssistent);
+    });
+  }
+  removeFilter() {
+    ConfigStorage.removePersonalizedFilter(this._filterAssistent, this.configName);
+  }
+  async handleFilterGroupChange() {
+    const assistent = await this._mainExpressionGroup.getExpressionGroup();
+    this._filterAssistent = Object.assign(Object.assign({}, this._filterAssistent), { assistent });
+    this._filterAssistent.parameters = PersonalizedFilterUtils.buildVariableParameters(this._filterAssistent.assistent);
+    this._elTextAreaExpression.value = PersonalizedFilterUtils.buildGroupExpression(this._filterAssistent.assistent, true);
+    this._elButtonSave.enabled = !this.hasChangesToSave();
+  }
+  hasChangesToSave() {
+    return JSON.stringify(this._filterAssistent) === JSON.stringify(this._originalFilterAssistent);
+  }
+  handleSave() {
+    const { assistent, expression } = this._filterAssistent;
+    const isValid = PersonalizedFilterUtils.validateFields(assistent);
+    if (!isValid || !this._filterAssistent.name)
+      return this._application.error(this.getMessage("snkPersonalizedFilter.error.title"), this.getMessage("snkPersonalizedFilter.error.description"));
+    const expressionQuery = !!assistent ? PersonalizedFilterUtils.buildGroupExpression(assistent) : expression;
+    this._filterAssistent.expression = expressionQuery;
+    this.ezSave.emit(expressionQuery);
+    this.saveFilter();
+  }
+  handleCancel() {
+    if (this.hasChangesToSave()) {
+      return this.ezCancel.emit();
+    }
+    ApplicationUtils.confirm(this.getMessage("snkPersonalizedFilter.confirmCancel.title"), this.getMessage("snkPersonalizedFilter.confirmCancel.description"))
+      .then((canCancel) => {
+      var _a;
+      if (canCancel) {
+        this._filterAssistent = ObjectUtils.copy((_a = this._originalFilterAssistent) !== null && _a !== void 0 ? _a : {});
+        this.ezCancel.emit();
+        this._elButtonSave.enabled = false;
+      }
+    });
+  }
+  handleTitleChange(name) {
+    this._filterAssistent = Object.assign(Object.assign({}, this._filterAssistent), { name });
+    this._elButtonSave.enabled = !this.hasChangesToSave();
+  }
+  addLabelToItems(resp) {
+    //Workaround: Alguns filtros foram salvos sem o fieldLabel. Para evitar transtornos
+    //tentamos usar o fieldLabel que pode estar informado no parametro.
+    if (resp.assistent && resp.assistent.items && resp.assistent.items.length > 0) {
+      resp.assistent.items.forEach(item => {
+        if (item.fieldLabel == undefined) {
+          const param = (resp.parameters || []).find(param => param.fieldName === item.fieldName);
+          if (param) {
+            item.fieldLabel = param.label;
+          }
+        }
+      });
+    }
+    return resp;
+  }
+  handleExpressionChange(expression) {
+    this._filterAssistent = Object.assign(Object.assign({}, this._filterAssistent), { expression });
+    this._elButtonSave.enabled = !this.hasChangesToSave();
+  }
+  getWarningMessageComponent() {
+    var _a;
+    if (StringUtils.isEmpty((_a = this._filterAssistent) === null || _a === void 0 ? void 0 : _a.warningMessage)) {
+      return undefined;
+    }
+    return (h("div", { class: "ez-flex" }, h("ez-alert", { alertType: "warn" }, this._filterAssistent.warningMessage)));
+  }
+  render() {
+    var _a, _b, _c, _d, _e;
+    if (!((_a = this._filterAssistent) === null || _a === void 0 ? void 0 : _a.assistent) && this._filterAssistentMode) {
+      return;
+    }
+    return (h(Host, null, h("div", { class: "snk-personalized-filter" }, h("div", null, h("snk-simple-bar", { label: this.filterId ? this.getMessage("snkPersonalizedFilter.info.titleEdit") : this.getMessage("snkPersonalizedFilter.info.titleAdd"), onExit: () => this.handleCancel() }, h("div", { class: "snk-personalized-filter__header-actions", slot: "rightSlot" }, h("ez-button", { size: "small", label: this.getMessage("snkPersonalizedFilter.info.labelCancel"), onClick: () => this.handleCancel() }), h("ez-button", { size: "small", ref: (el) => this._elButtonSave = el, enabled: false, class: "ez-button--primary", label: this.getMessage("snkPersonalizedFilter.info.labelSave"), onClick: this.handleSave.bind(this) })))), h("div", { class: "ez-box ez-margin-bottom--medium ez-box__main" }, h("div", { class: "ez-box__container" }, h("div", { class: "ez-flex ez-flex--column ez-size-width--full" }, h("div", { class: "ez-flex" }, h("ez-text-input", { class: "ez-padding-right--medium", label: this.getMessage("snkPersonalizedFilter.info.labelNameFilter"), value: (_b = this._filterAssistent) === null || _b === void 0 ? void 0 : _b.name, onEzChange: (evt) => this.handleTitleChange(evt.detail) })), this._filterAssistentMode ?
+      h(Fragment, null, h("div", { class: "ez-padding-top--small snk-personalized-filter__group" }, h("snk-expression-group", { ref: (el) => this._mainExpressionGroup = el, group: (_c = this._filterAssistent) === null || _c === void 0 ? void 0 : _c.assistent, messagesBuilder: this.messagesBuilder, onEzFilterGroupChange: this.handleFilterGroupChange.bind(this), filterId: this.filterId, entityURI: this.entityUri })), h("div", null, h("div", { class: "snk-personalized-filter__expression-input--line" }), h("ez-collapsible-box", { label: this.getMessage("snkPersonalizedFilter.info.titleCollapsible"), headerSize: "medium", value: true }, h("div", { class: "ez-box" }, h("div", { class: "ez-box__container" }, h("ez-text-area", { ref: (el) => this._elTextAreaExpression = el, enabled: false, label: this.getMessage("snkPersonalizedFilter.info.labelExpression"), value: (_d = this._filterAssistent) === null || _d === void 0 ? void 0 : _d.expression })))))) :
+      h(Fragment, null, h("span", { class: "ez-text ez-text--small ez-text--bold ez-padding-bottom--medium" }, "Express\u00E3o a ser aplicada:"), h("ez-text-area", { label: this.getMessage("snkPersonalizedFilter.info.labelExpression"), value: (_e = this._filterAssistent) === null || _e === void 0 ? void 0 : _e.expression, onEzChange: (evt) => this.handleExpressionChange(evt.detail) }), this.getWarningMessageComponent())))))));
+  }
+  static get watchers() { return {
+    "filterId": ["loadFilter"]
+  }; }
+  static get style() { return snkPersonalizedFilterCss; }
+}, [2, "snk-personalized-filter", {
+    "messagesBuilder": [1040],
+    "entityUri": [1025, "entity-uri"],
+    "filterId": [1025, "filter-id"],
+    "configName": [1025, "config-name"],
+    "_filterAssistentMode": [32],
+    "_filterAssistent": [32],
+    "createPersonalizedFilter": [64]
+  }]);
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["snk-personalized-filter", "snk-expression-group", "snk-expression-item", "snk-filter-field-search", "snk-filter-param-config", "snk-simple-bar"];
+  components.forEach(tagName => { switch (tagName) {
+    case "snk-personalized-filter":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, SnkPersonalizedFilter);
+      }
+      break;
+    case "snk-expression-group":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$5();
+      }
+      break;
+    case "snk-expression-item":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$4();
+      }
+      break;
+    case "snk-filter-field-search":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$3();
+      }
+      break;
+    case "snk-filter-param-config":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+    case "snk-simple-bar":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$1();
+      }
+      break;
+  } });
+}
+
+export { SnkPersonalizedFilter as S, defineCustomElement as d };

package/dist/esm/ConfigStorage-9f4d2e67.js

@@ -0,0 +1,300 @@
+import { ApplicationContext } from '@sankhyalabs/core';
+import { F as FormConfigFetcher } from './form-config-fetcher-cac8cd96.js';
+import { R as ResourceFetcher } from './resource-fetcher-02642924.js';
+import { F as FilterBarConfigFetcher } from './filter-bar-config-fetcher-bd2070a3.js';
+import { d as dist, D as DataFetcher } from './DataFetcher-b3d8b2d5.js';
+
+class GridConfigFetcher extends ResourceFetcher {
+  constructor() {
+    super(...arguments);
+    this.GRID_CONFIG_VERSION = "V3:";
+  }
+  getConfig(gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.loadResource(completePath)
+        .then(loadedResource => {
+        let config = undefined;
+        if (loadedResource) {
+          config = JSON.parse(loadedResource);
+        }
+        resolve(config);
+      }).catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveConfig(config, gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.saveResource(config, completePath)
+        .then((resp) => {
+        resolve(JSON.parse(resp.resource));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getPath(resourceID, name) {
+    if (name) {
+      return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}/${name}`;
+    }
+    return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}`;
+  }
+}
+
+class PersonalizedFilterFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buildTemplates();
+  }
+  resolveURI(resourceID, configName) {
+    let uri = "filter-assistent-config://" + resourceID;
+    if (configName) {
+      uri += "." + configName;
+    }
+    return uri;
+  }
+  buildTemplates() {
+    this.templateByQuery.set("fetchFilterFields", dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterFields(name: $name){
+        currentLink {
+          description
+          uri
+        }
+        links {
+          description
+          uri
+          fieldCount
+        }
+        fields {
+          name
+          description
+          uri
+          onlyDate
+          dataType
+          userInterface
+          entityName
+          properties {
+            name
+            value
+          }
+        }
+      }
+    }
+    `);
+    this.templateByQuery.set("fetchFilterAssistent", dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterAssistent(name: $name) {
+        id
+        name
+        active
+        expression
+        warningMessage
+        parameters {
+          entityName
+          fieldName
+          dataType
+          description
+          userInterface
+          label
+          searchContext {
+            entity
+            entityDescription
+            searchOptions {
+              rootEntity
+              descriptionFieldName
+              codeFieldName
+              showInactives
+            }
+          }
+        }
+        assistent
+      }
+    }`);
+    this.templateByQuery.set("savePersonalizedFilter", dist.gql ` 
+    mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
+      $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
+        id
+        name
+      }
+    }`);
+    this.templateByQuery.set("deletePersonalizedFilter", dist.gql `
+    mutation($name: String!, $filterId: String!) {
+      $queryAlias$: deletePersonalizedFilter(name: $name, filterId: $filterId) {
+        id
+        name
+      }
+    }`);
+  }
+  async loadPersonalizedFilter(resourceID, filterID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        query: this.templateByQuery.get("fetchFilterAssistent"),
+      })
+        .then((resp) => {
+        resp.assistent = JSON.parse(resp.assistent);
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    let personalizedFilterParsed = JSON.parse(JSON.stringify(personalizedFilter));
+    personalizedFilterParsed.assistent = JSON.stringify(personalizedFilterParsed.assistent);
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterAssistent: personalizedFilterParsed },
+        query: this.templateByQuery.get("savePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterId: personalizedFilter.id },
+        query: this.templateByQuery.get("deletePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadFields(uri) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: uri },
+        query: this.templateByQuery.get("fetchFilterFields"),
+      })
+        .then((resp) => {
+        var _a;
+        let fields = resp.fields;
+        for (const field of fields) {
+          if (Array.isArray(field.properties) && field.properties.length > 0) {
+            const propertiesConvertedObject = field.properties.reduce((accumulator, prop) => {
+              accumulator[prop.name] = prop.value;
+              return accumulator;
+            }, {});
+            field.properties = propertiesConvertedObject;
+          }
+          if ((_a = field === null || field === void 0 ? void 0 : field.properties) === null || _a === void 0 ? void 0 : _a.options) {
+            field.properties.options = JSON.parse(field.properties.options);
+          }
+        }
+        resolve(Object.assign(Object.assign({}, resp), { fields: fields }));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+const CONFIG_SOURCE = {
+  form: "form",
+  grid: "grid",
+  filterBar: "filterBar"
+};
+class ConfigStorage {
+  static async get() {
+    if (!ConfigStorage.instance) {
+      const application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      if (application != undefined) {
+        const configName = application.configName;
+        const resourceID = await application.getResourceID();
+        ConfigStorage.instance = new ConfigStorage();
+        ConfigStorage.resourceID = resourceID;
+        ConfigStorage.instance.loadFilterBarConfig(configName);
+        ConfigStorage.instance.loadFormConfig(configName);
+        ConfigStorage.instance.loadGridConfig(configName);
+      }
+    }
+    return this.instance;
+  }
+  async loadFilterBarConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.filterBarConfigFetcher.getConfig(ConfigStorage.resourceID, name));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadFormConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.form);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.formConfigFetcher.loadFormConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadGridConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.grid);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.gridConfigFetcher.getConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  static async saveFilterBarConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.filterBarConfigFetcher.saveConfig(config, this.resourceID, name);
+  }
+  static async saveFormConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.form);
+    this.configById.delete(cacheID);
+    return this.formConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async saveCardState(config, name) {
+    return this.formConfigFetcher.saveCardState(config, name, this.resourceID);
+  }
+  static async saveGridConfig(config, name) {
+    if (config == undefined) {
+      return;
+    }
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.grid);
+    this.configById.delete(cacheID);
+    return this.gridConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async loadPersonalizedFilter(filterId, configName) {
+    return this.personalizedFilterFetcher.loadPersonalizedFilter(this.resourceID, filterId, configName);
+  }
+  static async savePersonalizedFilter(personalizedFilter, configName) {
+    //Ao criar ou alterar um filtro personalizado, 
+    //precisamos remover o cache do status da filterbar.
+    const cacheID = this.buildCacheID(configName, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static async removePersonalizedFilter(personalizedFilter, configName) {
+    return this.personalizedFilterFetcher.removePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static buildCacheID(name, source) {
+    if (name == undefined) {
+      return `req_${source}_${this.resourceID}`;
+    }
+    return `req_${source}_${name}_${this.resourceID}`;
+  }
+}
+ConfigStorage.configById = new Map();
+ConfigStorage.filterBarConfigFetcher = new FilterBarConfigFetcher();
+ConfigStorage.formConfigFetcher = new FormConfigFetcher();
+ConfigStorage.gridConfigFetcher = new GridConfigFetcher();
+ConfigStorage.personalizedFilterFetcher = new PersonalizedFilterFetcher();
+
+export { ConfigStorage as C, GridConfigFetcher as G, PersonalizedFilterFetcher as P };

package/dist/esm/IExpressionItem-2e922b2c.js

@@ -0,0 +1,7 @@
+var FilterGroupCondition;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(FilterGroupCondition || (FilterGroupCondition = {}));
+
+export { FilterGroupCondition as F };