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

package/dist/collection/components/snk-taskbar/elements/taskbar-actions-button/taskbar-actions-button.js

@@ -0,0 +1,310 @@
+import { h, Host } from '@stencil/core';
+export class TaskbarActionsButton {
+  constructor() {
+    this._showDropdown = false;
+    this.title = undefined;
+    this.enabled = undefined;
+    this.actions = undefined;
+  }
+  async handleKeyDown(event) {
+    if (event.key === 'Escape' || event.key === 'Esc') {
+      await this.hideActions();
+    }
+  }
+  async handleClose() {
+    await this.hideActions();
+  }
+  /**
+   * Exibe a lista de ações.
+   */
+  async showActions() {
+    this._showDropdown = true;
+    requestAnimationFrame(() => {
+      this._element.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
+    });
+  }
+  /**
+   * Esaconde a lista de ações.
+   */
+  async hideActions() {
+    this._showDropdown = false;
+  }
+  /**
+   * Informa se a lista de ações está aberta.
+   */
+  async isOpened() {
+    return this._showDropdown;
+  }
+  controlDropdown() {
+    this._showDropdown = !this._showDropdown;
+  }
+  loadItems() {
+    return this.actions.filter(action => action !== undefined).map(action => {
+      var _a;
+      return {
+        id: action.value,
+        label: action.label,
+        value: action.value,
+        type: (_a = action.type) !== null && _a !== void 0 ? _a : 'item',
+        children: action.children,
+        iconName: action.iconName,
+        subAction: action.subAction,
+        group: action.group,
+        disableCloseOnSelect: action.disableCloseOnSelect,
+      };
+    });
+  }
+  canShowDropdown() {
+    var _a;
+    return this._showDropdown && ((_a = this.actions) === null || _a === void 0 ? void 0 : _a.length) > 0;
+  }
+  onSelectAction(iAction) {
+    const selectedAction = this.actions.find(action => action.value === iAction.id);
+    this.taskbarActionSelected.emit(selectedAction);
+    if (!selectedAction.disableCloseOnSelect) {
+      this._showDropdown = false;
+    }
+  }
+  dropdownItemBuilder(item, _level) {
+    const itemAction = this.actions.find(action => action.value === item.id);
+    if (!itemAction || !itemAction.itemBuilder) {
+      return undefined;
+    }
+    const customContent = itemAction.itemBuilder(this._element, itemAction);
+    if (typeof customContent === 'string') {
+      return h("div", { innerHTML: customContent });
+    }
+    return customContent;
+  }
+  /**
+   * Existem algumas actions que precisam ser inicializadas assim que o componente é carregado,
+   * pois necessitam de algumas informações, como por exemplo a referência do elemento taskbar-actions-button na tela.
+   * É o caso do searchColumn/searhField
+   */
+  initializeEagerItems() {
+    var _a;
+    (_a = this.actions) === null || _a === void 0 ? void 0 : _a.forEach(action => {
+      var _a;
+      if (action && action.eagerInitialize && action.itemBuilder) {
+        (_a = action.itemBuilder) === null || _a === void 0 ? void 0 : _a.call(action, this._element, action);
+      }
+    });
+  }
+  componentDidLoad() {
+    this.initializeEagerItems();
+  }
+  componentDidRender() {
+    if (this._showDropdown) {
+      this.taskbarActionsOpened.emit(this._element);
+    }
+  }
+  disconnectedCallback() {
+    this.taskbarActionsButtonDisconnected.emit();
+  }
+  render() {
+    return (h(Host, null, h("div", { class: `ez-padding-left--medium ${this.canShowDropdown() ? ' ez-elevation--16' : ''}` }, h("ez-button", { title: this.title, mode: 'icon', iconName: 'dots-vertical', size: 'small', enabled: this.enabled, onClick: () => this.controlDropdown() }), this.canShowDropdown() && h("ez-dropdown", { items: this.loadItems(), onEzClick: (evt) => this.onSelectAction(evt.detail), onEzOutsideClick: () => this._showDropdown = false, itemBuilder: (item, level) => this.dropdownItemBuilder(item, level) }))));
+  }
+  static get is() { return "taskbar-actions-button"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["taskbar-actions-button.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["taskbar-actions-button.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "title": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Texto que ser\u00E1 exibido no bot\u00E3o"
+        },
+        "attribute": "title",
+        "reflect": false
+      },
+      "enabled": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Se false o usu\u00E1rio n\u00E3o pode interagir com o componente."
+        },
+        "attribute": "enabled",
+        "reflect": false
+      },
+      "actions": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "Array<Action>",
+          "resolved": "Action[]",
+          "references": {
+            "Array": {
+              "location": "global"
+            },
+            "Action": {
+              "location": "import",
+              "path": "../../snk-taskbar"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define a lista de a\u00E7\u00F5es."
+        }
+      }
+    };
+  }
+  static get states() {
+    return {
+      "_showDropdown": {}
+    };
+  }
+  static get events() {
+    return [{
+        "method": "taskbarActionSelected",
+        "name": "taskbarActionSelected",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitido ao selecionar uma a\u00E7\u00E3o"
+        },
+        "complexType": {
+          "original": "Action",
+          "resolved": "Action",
+          "references": {
+            "Action": {
+              "location": "import",
+              "path": "../../snk-taskbar"
+            }
+          }
+        }
+      }, {
+        "method": "taskbarActionsOpened",
+        "name": "taskbarActionsOpened",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitido ao mostrar a lista de a\u00E7\u00F5es"
+        },
+        "complexType": {
+          "original": "HTMLElement",
+          "resolved": "HTMLElement",
+          "references": {
+            "HTMLElement": {
+              "location": "global"
+            }
+          }
+        }
+      }, {
+        "method": "taskbarActionsButtonDisconnected",
+        "name": "taskbarActionsButtonDisconnected",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitido quando componente \u00E9 desconectado da DOM"
+        },
+        "complexType": {
+          "original": "void",
+          "resolved": "void",
+          "references": {}
+        }
+      }];
+  }
+  static get methods() {
+    return {
+      "showActions": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Exibe a lista de a\u00E7\u00F5es.",
+          "tags": []
+        }
+      },
+      "hideActions": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Esaconde a lista de a\u00E7\u00F5es.",
+          "tags": []
+        }
+      },
+      "isOpened": {
+        "complexType": {
+          "signature": "() => Promise<boolean>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<boolean>"
+        },
+        "docs": {
+          "text": "Informa se a lista de a\u00E7\u00F5es est\u00E1 aberta.",
+          "tags": []
+        }
+      }
+    };
+  }
+  static get elementRef() { return "_element"; }
+  static get listeners() {
+    return [{
+        "name": "keydown",
+        "method": "handleKeyDown",
+        "target": "window",
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "ezOpenModal",
+        "method": "handleClose",
+        "target": "window",
+        "capture": false,
+        "passive": false
+      }];
+  }
+}

package/dist/collection/components/snk-taskbar/elements/taskbar-elements.js

@@ -86,7 +86,7 @@ export const buildElem = (element, className, dataElementId, getTitle, action, i
     case TaskbarElement.CONFIGURATOR:
       return iconButton("settings-inverted", element, className, dataElementId, title, action, isEnabled);
     case TaskbarElement.MORE_OPTIONS:
-      return actionButton(element, className, dataElementId, title, action, isEnabled, actions);
+      return actionButton(element, dataElementId, title, isEnabled, actions, action);
     case TaskbarElement.DIVIDER:
       return h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-horizontal--medium", "data-taskbar-divider": true });
     case TaskbarElement.DATA_EXPORTER:
@@ -107,8 +107,8 @@ function iconButton(iconName, name, className, dataElementId, title, action, isE
 function iconTextButton(iconName, name, className, dataElementId, text, title, action, isEnabled) {
   return h("ez-button", { key: dataElementId, title: title, label: text, size: "small", class: className, "data-element-id": dataElementId, enabled: isEnabled(name), onClick: () => action(name) }, h("ez-icon", { class: "ez-padding-right--small", slot: "leftIcon", iconName: iconName }));
 }
-function actionButton(element, className, dataElementId, title, action, isEnabled, actions) {
+function actionButton(element, dataElementId, title, isEnabled, actions, action) {
   return actions && actions.length > 0
-    ? h("ez-actions-button", { key: dataElementId, title: title, size: "small", "data-element-id": dataElementId, arrowActive: true, class: className, enabled: isEnabled(element), onEzAction: (evt) => action(evt.detail.value), actions: actions })
+    ? h("taskbar-actions-button", { key: dataElementId, title: title, "data-element-id": dataElementId, enabled: isEnabled(element), actions: actions, onTaskbarActionSelected: (evt) => action(evt.detail.value) })
     : undefined;
 }

package/dist/collection/components/snk-taskbar/snk-taskbar.css

@@ -1,7 +1,3 @@
 :host {
   display: flex;
 }
-
-.taskbar-custom-elements-container{
-  display: none;
-}

package/dist/collection/components/snk-taskbar/snk-taskbar.js

@@ -472,7 +472,7 @@ export class SnkTaskbar {
         "mutable": true,
         "complexType": {
           "original": "PresentationMode",
-          "resolved": "PresentationMode.PRIMARY | PresentationMode.SECONDARY",
+          "resolved": "PresentationMode.PRIMARY | PresentationMode.SECONDARY | PresentationMode.SINGLE_TASKBAR",
           "references": {
             "PresentationMode": {
               "location": "import",

package/dist/collection/components/snk-taskbar/subcomponents/field-search.js

@@ -0,0 +1,31 @@
+import { h } from '@stencil/core';
+const EVENT_NAME = 'taskbarActionsOpened';
+export const buildFieldSearch = (action, optionLoader, onSelectField) => {
+  return h("ez-search", { class: 'ez-actions-button--bottom-padding', canShowError: 'false', showSelectedValue: 'false', showOptionValue: 'false', suppressEmptyOption: 'true', label: action.label, value: '', optionLoader: optionLoader, onEzChange: (evt) => onSelectField(evt.detail), ignoreLimitCharsToSearch: true });
+};
+async function focusOnFieldSerch(field) {
+  requestAnimationFrame(async () => {
+    if (field) {
+      const realElement = field['$elm$'];
+      if (!realElement)
+        return;
+      realElement.value = null;
+      await realElement.setFocus();
+    }
+  });
+}
+export const openFieldSearch = async (moreOptions, field) => {
+  if (!moreOptions) {
+    return;
+  }
+  if ((await moreOptions.isOpened())) {
+    await focusOnFieldSerch(field);
+    return;
+  }
+  const eventHandler = () => {
+    focusOnFieldSerch(field);
+    moreOptions.removeEventListener(EVENT_NAME, eventHandler);
+  };
+  moreOptions.addEventListener(EVENT_NAME, eventHandler);
+  await moreOptions.showActions();
+};

package/dist/collection/lib/@types/index.js

@@ -2,6 +2,7 @@ export var PresentationMode;
 (function (PresentationMode) {
   PresentationMode["PRIMARY"] = "primary";
   PresentationMode["SECONDARY"] = "secondary";
+  PresentationMode["SINGLE_TASKBAR"] = "singleTaskbar";
 })(PresentationMode || (PresentationMode = {}));
 export var DataExporterOption;
 (function (DataExporterOption) {

package/dist/collection/lib/dataUnit/InMemoryLoader.js

@@ -1,25 +1,22 @@
-import { ChangeOperation, DataUnit, defaultDataLoader, StringUtils, } from '@sankhyalabs/core';
+import { ChangeOperation, DataType, DataUnit, DateUtils, StringUtils, } from '@sankhyalabs/core';
+import { ColumnFilterManager } from "@sankhyalabs/ezui/dist/collection/components/ez-grid/utils";
+import PreloadManager from '../http/data-fetcher/fetchers/data-unit/cache/PreloadManager';
 export default class InMemoryLoader {
   constructor(metadata, records) {
-    this.records = records;
     this.metadata = metadata;
+    this.records = records;
     this._dataUnit = new DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
     this._dataUnit.metadataLoader = () => this.metadaLoader();
-    this._dataUnit.dataLoader = (dataUnit, request) => defaultDataLoader(dataUnit, request, this.getRecordsToLoad());
+    this._dataUnit.dataLoader = (dataUnit, request) => this.inMemoryLoader(dataUnit, request, this.getRecordsToLoad());
     this._dataUnit.saveLoader = (_dataUnit, changes) => this.saveLoader(_dataUnit, changes);
     this._dataUnit.removeLoader = (_dataUnit, recordIds) => this.removeLoader(_dataUnit, recordIds);
     this.dataUnit.loadMetadata().then(() => this.dataUnit.loadData());
   }
   getRecordsToLoad() {
-    if (this._initialRecords) {
-      try {
-        return this._initialRecords;
-      }
-      finally {
-        this._initialRecords = undefined;
-      }
+    if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
+      this._initialRecords = this.dataUnit.records;
     }
-    return this.dataUnit.records;
+    return this._initialRecords;
   }
   get dataUnit() {
     return this._dataUnit;
@@ -27,18 +24,41 @@ export default class InMemoryLoader {
   get records() {
     return this.dataUnit.records;
   }
+  static getConvertedValue(descriptor, strValue) {
+    if (descriptor.dataType === DataType.BOOLEAN) {
+      return strValue === "S";
+    }
+    if (descriptor.dataType === DataType.NUMBER) {
+      return Number(strValue);
+    }
+    if (descriptor.dataType === DataType.DATE) {
+      return DateUtils.strToDate(strValue, true);
+    }
+    if (descriptor.dataType === DataType.OBJECT) {
+      return JSON.parse(strValue);
+    }
+    return strValue;
+  }
   set records(records) {
+    const columns = this._metadata ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor])) : undefined;
     const newRecords = records === null || records === void 0 ? void 0 : records.map(record => {
       if (!record["__record__id__"]) {
         record["__record__id__"] = this.generateUniqueId();
       }
+      if (columns != undefined) {
+        for (const name in record) {
+          const value = record[name];
+          if (typeof value === "string" && columns.has(name)) {
+            record[name] = InMemoryLoader.getConvertedValue(columns.get(name), value);
+          }
+        }
+      }
       return record;
     });
+    this._initialRecords = newRecords;
     if (this._dataUnit) {
-      this._dataUnit.records = newRecords;
-    }
-    else {
-      this._initialRecords = newRecords;
+      //Isso força o refresh internamente no datunit
+      this._dataUnit.gotoPage(0);
     }
   }
   get metadata() {
@@ -53,6 +73,32 @@ export default class InMemoryLoader {
   generateUniqueId() {
     return StringUtils.generateUUID();
   }
+  inMemoryLoader(dataUnit, request, recordsIn) {
+    let records = this.applyFilter(recordsIn, dataUnit, request.filters);
+    records = this.applySorting(records, dataUnit, request.sort);
+    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(request, records) });
+  }
+  applyFilter(records, dataUnit, filters) {
+    const columnFilters = ColumnFilterManager.getColumnFilters(filters, "");
+    if (columnFilters == undefined || columnFilters.size == 0) {
+      return records;
+    }
+    const filterFunciton = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    if (filterFunciton == undefined) {
+      return records;
+    }
+    return records.filter(filterFunciton);
+  }
+  applySorting(records, dataUnit, sorting) {
+    if (sorting == undefined || sorting.length == 0) {
+      return records;
+    }
+    const sortingFunction = PreloadManager.getSortingFunction(dataUnit, sorting);
+    if (sortingFunction == undefined) {
+      return records;
+    }
+    return records.sort(sortingFunction);
+  }
   metadaLoader() {
     return Promise.resolve(this._metadata);
   }
@@ -84,3 +130,16 @@ export default class InMemoryLoader {
   }
 }
 InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";
+function buildPaginationInfo({ offset, limit }, records) {
+  if (offset === undefined || limit === undefined) {
+    return undefined;
+  }
+  const lastRecord = Math.min(offset + limit, records.length);
+  return {
+    currentPage: Math.ceil(offset / limit),
+    firstRecord: offset,
+    lastRecord: lastRecord,
+    total: records.length,
+    hasMore: !!(records.length - lastRecord),
+  };
+}