@sankhyalabs/sankhyablocks 5.4.3 → 5.6.0

package/dist/components/snk-taskbar2.js

@@ -1,205 +1,11 @@
-import { getRenderingRef, forceUpdate, h, proxyCustomElement, HTMLElement, createEvent, Host } from '@stencil/core/internal/client';
+import { h, proxyCustomElement, HTMLElement, createEvent, Host } from '@stencil/core/internal/client';
 import { StringUtils, ApplicationContext, ElementIDUtils } from '@sankhyalabs/core';
 import { A as AuthorizationConfig } from './AuthorizationConfig.js';
 import { P as PresentationMode } from './index2.js';
+import { s as store } from './index3.js';
 import { d as defineCustomElement$2 } from './snk-data-exporter2.js';
 import { d as defineCustomElement$1 } from './snk-exporter-email-sender2.js';
 
-const appendToMap = (map, propName, value) => {
-    const items = map.get(propName);
-    if (!items) {
-        map.set(propName, [value]);
-    }
-    else if (!items.includes(value)) {
-        items.push(value);
-    }
-};
-const debounce = (fn, ms) => {
-    let timeoutId;
-    return (...args) => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => {
-            timeoutId = 0;
-            fn(...args);
-        }, ms);
-    };
-};
-
-/**
- * Check if a possible element isConnected.
- * The property might not be there, so we check for it.
- *
- * We want it to return true if isConnected is not a property,
- * otherwise we would remove these elements and would not update.
- *
- * Better leak in Edge than to be useless.
- */
-const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
-const cleanupElements = debounce((map) => {
-    for (let key of map.keys()) {
-        map.set(key, map.get(key).filter(isConnected));
-    }
-}, 2000);
-const stencilSubscription = () => {
-    if (typeof getRenderingRef !== 'function') {
-        // If we are not in a stencil project, we do nothing.
-        // This function is not really exported by @stencil/core.
-        return {};
-    }
-    const elmsToUpdate = new Map();
-    return {
-        dispose: () => elmsToUpdate.clear(),
-        get: (propName) => {
-            const elm = getRenderingRef();
-            if (elm) {
-                appendToMap(elmsToUpdate, propName, elm);
-            }
-        },
-        set: (propName) => {
-            const elements = elmsToUpdate.get(propName);
-            if (elements) {
-                elmsToUpdate.set(propName, elements.filter(forceUpdate));
-            }
-            cleanupElements(elmsToUpdate);
-        },
-        reset: () => {
-            elmsToUpdate.forEach((elms) => elms.forEach(forceUpdate));
-            cleanupElements(elmsToUpdate);
-        },
-    };
-};
-
-const unwrap = (val) => (typeof val === 'function' ? val() : val);
-const createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
-    const unwrappedState = unwrap(defaultState);
-    let states = new Map(Object.entries(unwrappedState !== null && unwrappedState !== void 0 ? unwrappedState : {}));
-    const handlers = {
-        dispose: [],
-        get: [],
-        set: [],
-        reset: [],
-    };
-    const reset = () => {
-        var _a;
-        // When resetting the state, the default state may be a function - unwrap it to invoke it.
-        // otherwise, the state won't be properly reset
-        states = new Map(Object.entries((_a = unwrap(defaultState)) !== null && _a !== void 0 ? _a : {}));
-        handlers.reset.forEach((cb) => cb());
-    };
-    const dispose = () => {
-        // Call first dispose as resetting the state would
-        // cause less updates ;)
-        handlers.dispose.forEach((cb) => cb());
-        reset();
-    };
-    const get = (propName) => {
-        handlers.get.forEach((cb) => cb(propName));
-        return states.get(propName);
-    };
-    const set = (propName, value) => {
-        const oldValue = states.get(propName);
-        if (shouldUpdate(value, oldValue, propName)) {
-            states.set(propName, value);
-            handlers.set.forEach((cb) => cb(propName, value, oldValue));
-        }
-    };
-    const state = (typeof Proxy === 'undefined'
-        ? {}
-        : new Proxy(unwrappedState, {
-            get(_, propName) {
-                return get(propName);
-            },
-            ownKeys(_) {
-                return Array.from(states.keys());
-            },
-            getOwnPropertyDescriptor() {
-                return {
-                    enumerable: true,
-                    configurable: true,
-                };
-            },
-            has(_, propName) {
-                return states.has(propName);
-            },
-            set(_, propName, value) {
-                set(propName, value);
-                return true;
-            },
-        }));
-    const on = (eventName, callback) => {
-        handlers[eventName].push(callback);
-        return () => {
-            removeFromArray(handlers[eventName], callback);
-        };
-    };
-    const onChange = (propName, cb) => {
-        const unSet = on('set', (key, newValue) => {
-            if (key === propName) {
-                cb(newValue);
-            }
-        });
-        // We need to unwrap the defaultState because it might be a function.
-        // Otherwise we might not be sending the right reset value.
-        const unReset = on('reset', () => cb(unwrap(defaultState)[propName]));
-        return () => {
-            unSet();
-            unReset();
-        };
-    };
-    const use = (...subscriptions) => {
-        const unsubs = subscriptions.reduce((unsubs, subscription) => {
-            if (subscription.set) {
-                unsubs.push(on('set', subscription.set));
-            }
-            if (subscription.get) {
-                unsubs.push(on('get', subscription.get));
-            }
-            if (subscription.reset) {
-                unsubs.push(on('reset', subscription.reset));
-            }
-            if (subscription.dispose) {
-                unsubs.push(on('dispose', subscription.dispose));
-            }
-            return unsubs;
-        }, []);
-        return () => unsubs.forEach((unsub) => unsub());
-    };
-    const forceUpdate = (key) => {
-        const oldValue = states.get(key);
-        handlers.set.forEach((cb) => cb(key, oldValue, oldValue));
-    };
-    return {
-        state,
-        get,
-        set,
-        on,
-        onChange,
-        use,
-        dispose,
-        reset,
-        forceUpdate,
-    };
-};
-const removeFromArray = (array, item) => {
-    const index = array.indexOf(item);
-    if (index >= 0) {
-        array[index] = array[array.length - 1];
-        array.length--;
-    }
-};
-
-const createStore = (defaultState, shouldUpdate) => {
-    const map = createObservableMap(defaultState, shouldUpdate);
-    map.use(stencilSubscription());
-    return map;
-};
-
-const store = createStore({
-  exporterProviders: {}
-});
-
 var TaskbarElement;
 (function (TaskbarElement) {
   TaskbarElement["PREVIOUS"] = "PREVIOUS";
@@ -217,6 +23,7 @@ var TaskbarElement;
   TaskbarElement["DIVIDER"] = "DIVIDER";
   TaskbarElement["CONFIGURATOR"] = "CONFIGURATOR";
   TaskbarElement["DATA_EXPORTER"] = "DATA_EXPORTER";
+  TaskbarElement["ATTACH"] = "ATTACH";
 })(TaskbarElement || (TaskbarElement = {}));
 var AuthorizationElements;
 (function (AuthorizationElements) {
@@ -289,6 +96,8 @@ const buildElem = (element, className, dataElementId, getTitle, action, isEnable
     case TaskbarElement.DATA_EXPORTER:
       const provider = (_a = store.get("exporterProviders")) === null || _a === void 0 ? void 0 : _a[configName];
       return h("snk-data-exporter", { class: className, provider: provider, "data-element-id": dataElementId });
+    case TaskbarElement.ATTACH:
+      return iconButton("anexo", element, className, dataElementId, title, action, isEnabled);
   }
 };
 function textButton(name, className, dataElementId, text, title, action, isEnabled) {
@@ -327,7 +136,8 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
       [TaskbarElement.SAVE]: "snkTaskbar.titleSave",
       [TaskbarElement.GRID_MODE]: "snkTaskbar.titleGridMode",
       [TaskbarElement.FORM_MODE]: "snkTaskbar.titleFormMode",
-      [TaskbarElement.CONFIGURATOR]: "snkTaskbar.titleConfigurator"
+      [TaskbarElement.CONFIGURATOR]: "snkTaskbar.titleConfigurator",
+      [TaskbarElement.ATTACH]: "snkTaskbar.titleAttach",
     };
     this._permissions = undefined;
     this.configName = undefined;
@@ -434,7 +244,8 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     if (index > 1) {
       className += "ez-padding-left--medium";
     }
-    if (TaskbarElement[def.toString()]) {
+    const taskbarElement = TaskbarElement[def.toString()];
+    if (taskbarElement) {
       return buildElem(def, className, this.getIdElemBtnNative(def), elem => this.getTitle(elem), elem => this.elementClick(elem), elem => this.isEnabled(elem), this.actionsList, this.configName, this.presentationMode);
     }
     else {
@@ -548,4 +359,4 @@ function defineCustomElement() {
   } });
 }
 
-export { SnkTaskbar as S, TaskbarElement as T, defineCustomElement as d, store as s };
+export { SnkTaskbar as S, TaskbarElement as T, defineCustomElement as d };

package/dist/esm/{SnkMessageBuilder-a15d22f8.js → SnkMessageBuilder-f3590f65.js}

@@ -73,6 +73,7 @@ const snkTaskbarMessages = {
   titleGridMode: "Modo Grade",
   titleFormMode: "Modo Formulário",
   titleConfigurator: "Configurações",
+  titleAttach: "Anexar",
   forbidden: "Permissão não liberada"
 };
 
@@ -278,6 +279,50 @@ const snkFilterFieldSearchMessages = {
   linkLabel: "Categorias de {{link}}",
 };
 
+const snkSimpleBarMessages = {
+  backTitle: "Voltar"
+};
+
+const snkAttachMessages = {
+  title: "Anexar arquivos",
+  description: "Faça o upload dos arquivos ou informe links que deseja anexar ao título",
+  attachHint: "Fazer download do arquivo",
+  breadcrumbTitle: "Anexar",
+  finishedMessage: "O anexo foi finalizado com sucesso",
+  finish: "Finalizar",
+  cancelConfirmation: {
+    title: "Atenção",
+    message: "As alterações realizadas não serão aplicadas.<br/><br/><b>Deseja mesmo continuar?</b>",
+  },
+  alertValidation: {
+    fileAndLinkAtTheSameTime: {
+      title: "Atenção",
+      message: "Não é permitido inserir o arquivo e o link ao mesmo tempo."
+    },
+    anyLinkOrFileFilled: {
+      title: "Atenção",
+      message: `É necessário preencher o campo "Link" ou anexar um arquivo.`
+    }
+  },
+  taskbar: {
+    titleDownload: "Fazer download",
+    titleLink: "Abrir link",
+  }
+};
+
+const snkPersonalizedFilterMessages = {
+  info: {
+    labelSearchField: "Buscar campo",
+    labelOperator: "Operador",
+    labelValueVarible: "Valor variável",
+    titleTooltip: "Ao ativar um valor variável, é possível inserir um valor diferente sempre que o filtro for aplicado"
+  },
+  confirm: {
+    title: "Aviso",
+    description: `As informações da condição serão descartadas.</br></br><b>Gostaria de continuar?</b>`
+  }
+};
+
 class SnkMessageBuilder {
   constructor(domainName) {
     this._defaults = {
@@ -297,7 +342,10 @@ class SnkMessageBuilder {
       snkCrud: snkCrudMessages,
       fileViewer: fileViewerMessages,
       snkFilterParamConfig: snkFilterParamConfigMessages,
-      snkFilterFieldSearch: snkFilterFieldSearchMessages
+      snkFilterFieldSearch: snkFilterFieldSearchMessages,
+      snkSimpleBar: snkSimpleBarMessages,
+      snkAttach: snkAttachMessages,
+      snkPersonalizedFilter: snkPersonalizedFilterMessages
     };
     this._currentOperation = OperationMap.CLEAN;
     this._domainName = domainName;

package/dist/esm/{constants-15617e7d.js → constants-e916ccc3.js}

@@ -4,6 +4,7 @@ var VIEW_MODE;
 (function (VIEW_MODE) {
   VIEW_MODE[VIEW_MODE["GRID"] = 0] = "GRID";
   VIEW_MODE[VIEW_MODE["FORM"] = 1] = "FORM";
+  VIEW_MODE[VIEW_MODE["ATTACHMENT"] = 2] = "ATTACHMENT";
 })(VIEW_MODE || (VIEW_MODE = {}));
 const ACTION_CONFIG = {
   add: 'ADD',

package/dist/esm/dataunit-fetcher-d32c6a47.js

@@ -0,0 +1,317 @@
+import { DataUnit, StringUtils, DataType, DataUnitStorage, ChangeOperation } from '@sankhyalabs/core';
+import { d as dist, D as DataFetcher } from './DataFetcher-b3d8b2d5.js';
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+class DataUnitFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this._loadDataTimeout = {};
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchDataUnit", dist.gql `query($name: String!) {
+              $queryAlias$: fetchDataUnit(name: $name){
+                name
+                fields{
+                  name
+                  defaultValue
+                  label
+                  visible
+                  readOnly
+                  required
+                  dataType
+                  userInterface
+                  calculated
+                  group
+                  order
+                  properties{
+                    name
+                    value
+                  }
+                  dependencies{
+                    masterFields
+                    type
+                    expression
+                  }
+                }
+                children{
+                  name
+                  label
+                  links{
+                    source
+                    target
+                  }
+                }
+              }
+            }`);
+    this.templateByQuery.set("fetchData", dist.gql `query($dataunit: String! $limit: Int $offset:Int $filters: [InputFilter!] $sort: [InputSort!] $parentRecordId: String) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              data(limit: $limit offset: $offset filters: $filters sort: $sort parentRecordId: $parentRecordId){
+                limit
+                offset
+                total
+                hasMore
+                records{
+                  id
+                  label
+                  fields {
+                    name
+                    value
+                  }
+                }
+              }
+            }
+          }`);
+    this.templateByQuery.set("saveData", dist.gql `mutation($changes: [InputBatchChange!]!) {
+            $queryAlias$: batchOperationDataUnit(changes: $changes){
+              oldId
+              id
+              label
+              ownerDataUnitName
+              fields {
+                name
+                value
+              }
+            }
+          }`);
+    this.templateByQuery.set("fetchDataRecord", dist.gql `query($dataunit: String! $recordID: [String!]) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              record(id: $recordID){
+                id
+                label
+                fields {
+                  name
+                  value
+                }
+              }
+            }
+          }`);
+  }
+  getDataUnit(entityName, resourceID, parentDataUnit) {
+    const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(`dd://${entityName}/${resourceID}`) : new DataUnit(`dd://${entityName}/${resourceID}`);
+    dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
+    dataUnit.dataLoader = (dataUnit, request) => this.loadData(dataUnit, request);
+    dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
+    dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
+    dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
+    return dataUnit;
+  }
+  loadMetadata(dataUnit) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataUnit"),
+      })
+        .then((resp) => {
+        var _a;
+        const metadata = {
+          name: resp.name,
+          label: resp.name,
+          children: [...resp.children],
+          fields: []
+        };
+        (_a = resp.fields) === null || _a === void 0 ? void 0 : _a.forEach((source) => {
+          let properties = undefined;
+          if (Array.isArray(source.properties)) {
+            properties = {};
+            if (source.calculated) {
+              properties.gridHeaderTooltip = "Campos calculados não podem ser ordenados";
+            }
+            source.properties.forEach((prop) => (properties[prop.name] = prop.value));
+          }
+          metadata.fields.push(Object.assign(Object.assign({}, source), { properties }));
+        });
+        metadata.fields.sort((a, b) => a.order - b.order);
+        resolve(metadata);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadData(dataUnit, request) {
+    const duName = dataUnit.name;
+    if (this._loadDataTimeout[duName]) {
+      clearTimeout(this._loadDataTimeout[duName]);
+      delete this._loadDataTimeout[duName];
+    }
+    return new Promise((resolve, reject) => {
+      this._loadDataTimeout[duName] = setTimeout(() => {
+        delete this._loadDataTimeout[duName];
+        this.doLoadData(dataUnit, request)
+          .then(result => resolve(result))
+          .catch(reason => reject(reason));
+      }, 200);
+    });
+  }
+  doLoadData(dataUnit, request) {
+    return new Promise((resolve, reject) => {
+      var _a;
+      const { sort, filters, limit, offset, quickFilter } = request;
+      const variables = { dataunit: dataUnit.name, sort, filters };
+      variables.limit = limit;
+      variables.offset = offset;
+      variables.parentRecordId = request.parentRecordId;
+      if (!StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
+        if (variables.filter === undefined) {
+          variables.filter = [];
+        }
+        const quickFilterCriteria = {
+          name: "__QUICK_FILTER__",
+          expression: "__QUICK_FILTER__",
+          params: [{ name: "term", dataType: DataType.TEXT, value: quickFilter.term }]
+        };
+        if (((_a = quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+          quickFilterCriteria.params.push({ name: "fields", dataType: DataType.OBJECT, value: quickFilter.fields });
+        }
+        variables.filter.push(quickFilterCriteria);
+      }
+      DataFetcher.get()
+        .callGraphQL({
+        values: variables,
+        query: this.templateByQuery.get("fetchData"),
+      })
+        .then((resp) => {
+        const { limit, offset, total, hasMore, records } = resp.data;
+        let paginationInfo;
+        if (limit) {
+          const firstRecord = total == 0 ? 0 : offset + 1;
+          const lastRecord = offset + Math.min(records.length, limit);
+          const currentPage = offset / limit;
+          paginationInfo = {
+            firstRecord,
+            lastRecord,
+            total,
+            currentPage,
+            hasMore
+          };
+        }
+        const processedRecords = [];
+        records.forEach((responseRecord) => {
+          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          processedRecords.push(duRecord);
+        });
+        resolve({
+          paginationInfo,
+          records: processedRecords
+        });
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveData(dataUnit, duChanges) {
+    const changes = duChanges.map((change) => {
+      const { dataUnit: changeDU, record, updatingFields, operation } = change;
+      const dataUnitInstance = DataUnitStorage.get(changeDU);
+      let parsedUpdatingFields;
+      if (updatingFields) {
+        parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
+          const descriptor = dataUnitInstance.getField(fieldName);
+          const dataType = descriptor ? descriptor.dataType : DataType.TEXT;
+          return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
+        });
+      }
+      const reqChange = { dataUnit: changeDU, fields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
+      if (change.sourceId) {
+        reqChange.sourceId = change.sourceId;
+      }
+      if (record.__parent__record__id__) {
+        reqChange.parentRecordId = record.__parent__record__id__;
+      }
+      return reqChange;
+    });
+    return new Promise((resolve, reject) => {
+      const changesFormatted = changes.map((_a) => {
+        var rest = __rest(_a, []);
+        return rest;
+      });
+      DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changesFormatted },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((resp) => {
+        const dataUnitRecords = [];
+        resp === null || resp === void 0 ? void 0 : resp.forEach((responseRecord) => {
+          const duRecord = {
+            __record__id__: responseRecord.id,
+            __record__label__: responseRecord.label,
+            __owner__dataunit__name__: responseRecord.ownerDataUnitName,
+          };
+          const dataUnitInstance = DataUnitStorage.get(duRecord.__owner__dataunit__name__) || dataUnit;
+          if (responseRecord.oldId) {
+            duRecord.__old__id__ = responseRecord.oldId;
+          }
+          responseRecord.fields.forEach(({ name, value }) => {
+            var _a;
+            duRecord[name] = ((_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value)) || value;
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  removeRecords(dataUnit, recordIds) {
+    const changes = recordIds.map((recordId) => {
+      return { dataUnit: dataUnit.name, operation: ChangeOperation.DELETE, recordId };
+    });
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changes },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((_resp) => {
+        resolve(recordIds);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadRecord(dataUnit, recordIds) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { recordID: recordIds, dataunit: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataRecord"),
+      })
+        .then((response) => {
+        const dataUnitRecords = [];
+        response.record.forEach(responseRecord => {
+          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+export { DataUnitFetcher as D };

package/dist/esm/{index-6519a79e.js → index-507e19ec.js}

@@ -64,4 +64,4 @@ var FilterEntities;
   FilterEntities["INSTANCE"] = "Instancia";
 })(FilterEntities || (FilterEntities = {}));
 
-export { DataExporterOption as D, FilterOperand as F, PresentationMode as P, DataExporterFormat as a, DataExporterType as b, FilterConfigType as c, FilterEntities as d, FilterUserConfigTypes as e };
+export { DataExporterOption as D, FilterUserConfigTypes as F, PresentationMode as P, DataExporterFormat as a, DataExporterType as b, FilterOperand as c, FilterConfigType as d, FilterEntities as e };

package/dist/esm/index-620ac460.js

@@ -0,0 +1,7 @@
+var SelectedItemType;
+(function (SelectedItemType) {
+  SelectedItemType["LINK"] = "LINK";
+  SelectedItemType["FIELD"] = "FIELD";
+})(SelectedItemType || (SelectedItemType = {}));
+
+export { SelectedItemType as S };

package/dist/esm/{index-e467ade5.js → index-8efbf198.js}

@@ -192,7 +192,8 @@ const createStore = (defaultState, shouldUpdate) => {
 };
 
 const store = createStore({
-  exporterProviders: {}
+  exporterProviders: {},
+  filterFieldsDataSource: undefined
 });
 
 export { store as s };