@sankhyalabs/sankhyablocks 0.0.0-bugfix-dev-KB-11997.0

package/dist/cjs/filter-item-type.enum-aa823a00.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var FilterItemType;
+(function (FilterItemType) {
+  FilterItemType["MULTI_SELECT"] = "MULTI_SELECT";
+  FilterItemType["BINARY_SELECT"] = "BINARY_SELECT";
+  FilterItemType["PERIOD"] = "PERIOD";
+  FilterItemType["SEARCH"] = "SEARCH";
+  FilterItemType["TEXT"] = "TEXT";
+  FilterItemType["NUMBER"] = "NUMBER";
+  FilterItemType["DEFAULT_FILTER"] = "DEFAULT_FILTER";
+  FilterItemType["PERSONALIZED"] = "PERSONALIZED";
+  FilterItemType["MULTI_LIST"] = "MULTI_LIST";
+})(FilterItemType || (FilterItemType = {}));
+const FilterItemType$1 = FilterItemType;
+
+exports.FilterItemType = FilterItemType$1;

package/dist/cjs/filter-type.enum-b14ce507.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var FilterType;
+(function (FilterType) {
+  FilterType["QUICK_FILTER"] = "QUICK_FILTER";
+  FilterType["CUSTOM_FILTER"] = "CUSTOM_FILTER";
+  FilterType["OTHER_FILTERS"] = "OTHER_FILTERS";
+})(FilterType || (FilterType = {}));
+const FilterType$1 = FilterType;
+
+exports.FilterType = FilterType$1;

package/dist/cjs/form-config-fetcher-f6cb55e6.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const DataFetcher = require('./DataFetcher-bd3d53a8.js');
+const core = require('@sankhyalabs/core');
+
+class ResourceFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchResource", DataFetcher.dist.gql `query($name: String!) {
+                    $queryAlias$: fetchResource(name: $name){
+                        resource
+                    }
+                  }`);
+    this.templateByQuery.set("saveResource", DataFetcher.dist.gql `mutation($resource: InputResource!) {
+                $queryAlias$: saveResource(resource: $resource){
+                    name
+                    resource                    
+                }
+              }`);
+  }
+  loadResource(name) {
+    if (ResourceFetcher._loadingResource.has(name)) {
+      return ResourceFetcher._loadingResource.get(name);
+    }
+    const promiseLoadResource = new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name },
+        query: this.templateByQuery.get("fetchResource"),
+      })
+        .then((result) => {
+        resolve(result === null || result === void 0 ? void 0 : result.resource);
+        ResourceFetcher._loadingResource.delete(name);
+      })
+        .catch((error) => {
+        reject(error);
+        ResourceFetcher._loadingResource.delete(name);
+      });
+    });
+    ResourceFetcher._loadingResource.set(name, promiseLoadResource);
+    return promiseLoadResource;
+  }
+  saveResource(resource, name) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: {
+          resource: {
+            name: name,
+            resource: JSON.stringify(resource)
+          }
+        },
+        query: this.templateByQuery.get("saveResource")
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+ResourceFetcher._loadingResource = new Map();
+
+class FormConfigFetcher extends ResourceFetcher {
+  constructor() {
+    super();
+    this.queryConfig = new Map();
+    this.buildTemplatesConfig();
+  }
+  buildTemplatesConfig() {
+    this.queryConfig.set("fetchUserAvailableConfigs", DataFetcher.dist.gql `query($name: String!) {
+                    $queryAlias$: fetchUserAvailableConfigs(name: $name){
+                        name
+                        origin
+                        key
+                  }
+                }`);
+    this.queryConfig.set("fetchLegacyConfig", DataFetcher.dist.gql `query($name: String!) {
+                    $queryAlias$: fetchLegacyConfig(name: $name){
+                        name
+                        resource
+                  }
+                }`);
+    this.queryConfig.set("fetchDefaultConfig", DataFetcher.dist.gql `query($name: String!) {
+                    $queryAlias$: fetchDefaultConfig(name: $name){
+                        name
+                        resource
+                  }
+                }`);
+  }
+  loadFormConfig(formName, resourceID) {
+    return new Promise((accept, reject) => {
+      Promise.all([
+        this.loadResource(this.getPath(resourceID, formName)),
+        this.loadResource(this.getPath(`FormCardState:${resourceID}`, formName, "form-card")),
+        this.loadResource(this.getPath(resourceID, formName, "summary")),
+        this.loadResource(this.getPath(resourceID, formName, "defaultValues"))
+      ])
+        .then(([configAsString, formCardState, summary, defaultValues]) => {
+        let config;
+        if (configAsString != undefined) {
+          config = Object.assign(Object.assign({}, JSON.parse(configAsString)), { emptyConfig: false });
+          const { tabs, fields } = config;
+          if (tabs) {
+            const allTabs = new Map(tabs.map(t => [t.label, t]));
+            fields === null || fields === void 0 ? void 0 : fields.forEach(f => { var _a; return f.tab = ((_a = allTabs.get(this.getTabName(f.tab))) === null || _a === void 0 ? void 0 : _a.label) || allTabs.get(this.getTabName(f.tab)); });
+          }
+          config.fields = fields === null || fields === void 0 ? void 0 : fields.map((field) => {
+            if ("readonly" in field) {
+              const readOnly = field['readonly'] === true;
+              delete field['readonly'];
+              field.readOnly = readOnly;
+            }
+            return field;
+          });
+        }
+        if (formCardState != undefined) {
+          if (config == undefined) {
+            config = { emptyConfig: true, fields: [] };
+          }
+          config.cardsState = new Map(JSON.parse(formCardState));
+        }
+        if (summary != undefined) {
+          if (config == undefined) {
+            config = { emptyConfig: true, fields: [] };
+          }
+          config.summary = new Map(Object.entries(JSON.parse(summary)));
+        }
+        if (defaultValues != undefined) {
+          if (config == undefined) {
+            config = { emptyConfig: true, fields: [] };
+          }
+          config.defaultVars = new Map(Object.entries(JSON.parse(defaultValues)));
+        }
+        accept(config);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getTabName(tab) {
+    if (typeof tab === 'object') { // ITabConfig type
+      return tab.label;
+    }
+    return tab; //string type
+  }
+  saveCardState(cardsState, formName, resourceID) {
+    const completePath = this.getPath(`FormCardState:${resourceID}`, formName, "form-card");
+    return new Promise((resolve, reject) => {
+      this.saveResource(Array.from(cardsState.entries()), completePath)
+        .then((resp) => {
+        resolve(new Map(JSON.parse(resp.resource)));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveConfig(config, formName, resourceID) {
+    //Essas informações não devem ser salvas na configuração
+    delete config.cardsState;
+    delete config.defaultVars;
+    delete config.summary;
+    const completePath = this.getPath(resourceID, formName);
+    return new Promise((resolve, reject) => {
+      this.saveResource(config, completePath)
+        .then((resp) => {
+        resolve(JSON.parse(resp.resource));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  fetchUserAvailableConfigs(formName, resourceID) {
+    const name = this.getPath(resourceID, formName);
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name },
+        query: this.queryConfig.get("fetchUserAvailableConfigs"),
+      })
+        .then((result) => {
+        resolve(result);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  fetchLegacyConfig(formName, resourceID) {
+    const name = this.getPath(resourceID, formName);
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name },
+        query: this.queryConfig.get("fetchLegacyConfig"),
+      })
+        .then((result) => {
+        resolve(core.ObjectUtils.stringToObject((result === null || result === void 0 ? void 0 : result.resource) || ''));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  fetchDefaultConfig(formName, resourceID) {
+    const name = this.getPath(resourceID, formName);
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name },
+        query: this.queryConfig.get("fetchDefaultConfig"),
+      })
+        .then((result) => {
+        resolve(core.ObjectUtils.stringToObject((result === null || result === void 0 ? void 0 : result.resource) || ''));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getPath(resourceID, name, authority = "form") {
+    if (name) {
+      return `cfg://${authority}/${resourceID}/${name}`;
+    }
+    return `cfg://${authority}/${resourceID}`;
+  }
+}
+exports.UserConfigType = void 0;
+(function (UserConfigType) {
+  UserConfigType["USER"] = "USER";
+  UserConfigType["DEFAULT"] = "DEFAULT";
+  UserConfigType["SHARED"] = "SHARED";
+})(exports.UserConfigType || (exports.UserConfigType = {}));
+
+exports.FormConfigFetcher = FormConfigFetcher;
+exports.ResourceFetcher = ResourceFetcher;

package/dist/cjs/index-0e663819.js

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.PresentationMode = void 0;
+(function (PresentationMode) {
+  PresentationMode["PRIMARY"] = "primary";
+  PresentationMode["SECONDARY"] = "secondary";
+})(exports.PresentationMode || (exports.PresentationMode = {}));
+exports.DataExporterOption = void 0;
+(function (DataExporterOption) {
+  DataExporterOption["EXPORT_TO_PDF"] = "exportToPDF";
+  DataExporterOption["EXPORT_TO_XLS"] = "exportToXLS";
+  DataExporterOption["EXPORT_CURRENT_PAGE"] = "exportCurrentPage";
+  DataExporterOption["EXPORT_PAGE_TO_PDF"] = "exportPageToPDF";
+  DataExporterOption["EXPORT_PAGE_TO_XLS"] = "exportPageToXLS";
+  DataExporterOption["EXPORT_BY_EMAIL"] = "exportToEmail";
+  DataExporterOption["EXPORT_PDF_TO_EMAIL"] = "exportPDFToEmail";
+  DataExporterOption["EXPORT_XLS_TO_EMAIL"] = "exportXLSToEmail";
+})(exports.DataExporterOption || (exports.DataExporterOption = {}));
+exports.DataExporterFormat = void 0;
+(function (DataExporterFormat) {
+  DataExporterFormat["PDF"] = "exportPDFToEmail";
+  DataExporterFormat["XLS"] = "exportXLSToEmail";
+  DataExporterFormat["XLSX"] = "exportXLSToEmail";
+})(exports.DataExporterFormat || (exports.DataExporterFormat = {}));
+exports.DataExporterType = void 0;
+(function (DataExporterType) {
+  DataExporterType["EXPORT_TO_PDF"] = "PDF";
+  DataExporterType["EXPORT_TO_XLS"] = "XLS";
+  DataExporterType["EXPORT_PAGE_TO_PDF"] = "PDF";
+  DataExporterType["EXPORT_PAGE_TO_XLS"] = "XLS";
+  DataExporterType["EXPORT_PDF_TO_EMAIL"] = "PDF";
+  DataExporterType["EXPORT_XLS_TO_EMAIL"] = "XLS";
+})(exports.DataExporterType || (exports.DataExporterType = {}));

package/dist/cjs/index-102ba62d.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const index = require('./index-f9e81701.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 index.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 = index.getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        },
+        set: (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(index.forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        },
+        reset: () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(index.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: {},
+  filterFieldsDataSource: undefined
+});
+
+exports.store = store;

package/dist/cjs/index-8d94b7e0.js

@@ -0,0 +1,7 @@
+'use strict';
+
+exports.SelectedItemType = void 0;
+(function (SelectedItemType) {
+  SelectedItemType["LINK"] = "LINK";
+  SelectedItemType["FIELD"] = "FIELD";
+})(exports.SelectedItemType || (exports.SelectedItemType = {}));

package/dist/cjs/index-c5771aba.js

@@ -0,0 +1,44 @@
+'use strict';
+
+exports.FilterGroupCondition = void 0;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(exports.FilterGroupCondition || (exports.FilterGroupCondition = {}));
+
+exports.FilterConfigType = void 0;
+(function (FilterConfigType) {
+  FilterConfigType["SYSTEM_CONFIG"] = "S";
+  FilterConfigType["USER_CONFIG"] = "E";
+})(exports.FilterConfigType || (exports.FilterConfigType = {}));
+exports.FilterUserConfigTypes = void 0;
+(function (FilterUserConfigTypes) {
+  FilterUserConfigTypes["DATE"] = "D";
+  FilterUserConfigTypes["HORA"] = "H";
+  FilterUserConfigTypes["TEXT"] = "S";
+  FilterUserConfigTypes["INTEGER"] = "I";
+  FilterUserConfigTypes["DECIMAL"] = "F";
+  FilterUserConfigTypes["NUMBER"] = "NUMBER";
+})(exports.FilterUserConfigTypes || (exports.FilterUserConfigTypes = {}));
+exports.FilterOperand = void 0;
+(function (FilterOperand) {
+  FilterOperand["AND"] = "AND";
+  FilterOperand["OR"] = "OR";
+  FilterOperand["IN"] = "IN";
+  FilterOperand["DIFFERENT"] = "<>";
+  FilterOperand["LIKE"] = "LIKE";
+  FilterOperand["START_WITH"] = "LIKE_START";
+  FilterOperand["FINISHED_WITH"] = "LIKE_END";
+  FilterOperand["NULL"] = "NULL";
+  FilterOperand["NOT_NULL"] = "NOT NULL";
+  FilterOperand["EQUAL"] = "=";
+  FilterOperand["LARGER"] = ">";
+  FilterOperand["LARGER_EQUAL"] = ">=";
+  FilterOperand["SMALLER"] = "<";
+  FilterOperand["SMALLER_EQUAL"] = "<=";
+})(exports.FilterOperand || (exports.FilterOperand = {}));
+exports.FilterEntities = void 0;
+(function (FilterEntities) {
+  FilterEntities["FIELD"] = "Campo";
+  FilterEntities["INSTANCE"] = "Instancia";
+})(exports.FilterEntities || (exports.FilterEntities = {}));