@sankhyalabs/ezui 0.0.0-bugfix-dev-KB-08202.0

package/dist/collection/components/ez-tree/subcomponents/DefaultTooltipResolver.js

@@ -0,0 +1,3 @@
+export const defaultTooltipResolver = (item, _enabled, _level) => {
+  return item.tooltip || item.label;
+};

package/dist/collection/components/ez-tree/subcomponents/TreeItem.js

@@ -0,0 +1,24 @@
+import { ElementIDUtils } from "@sankhyalabs/core";
+import { h } from "@stencil/core";
+export const TreeItem = (props) => {
+  const { node, selectedId, itemClick, iconClick, iconResolver, tooltipResolver, itemsList } = props;
+  if (!node.visible) {
+    return;
+  }
+  const treeItem = node.item;
+  const level = props.level || 1;
+  const disabled = node.isDisabled();
+  const expanded = !disabled && treeItem.expanded;
+  const expandable = node.isExpandable();
+  const available = !disabled && !node.isPlaceHolder;
+  if (available) {
+    itemsList.push(treeItem);
+  }
+  return (h("ul", { class: level === 1 ? "first-level" : undefined }, h("li", Object.assign({ title: tooltipResolver(treeItem, !disabled, level), class: "tree-item", onClick: () => available && itemClick(treeItem) }, {
+    disabled,
+    selected: treeItem.id === selectedId,
+    [ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME]: ElementIDUtils.getInternalIDInfo(`ezTreeItem_${treeItem.id}`)
+  }), h("div", { class: "item-icon-box" }, expandable &&
+    h("ez-icon", { id: treeItem.id, class: "item-icon", size: "small", iconName: iconResolver(treeItem, expanded, level), onClick: () => available && iconClick(treeItem) })), h("label", { class: "item-label" }, treeItem.label)), expanded
+    && node.getChildren().map(child => h(TreeItem, { selectedId: selectedId, node: child, itemClick: itemClick, iconClick: iconClick, level: level + 1, iconResolver: iconResolver, tooltipResolver: tooltipResolver, itemsList: itemsList }))));
+};

package/dist/collection/components/ez-tree/subcomponents/index.js

@@ -0,0 +1,2 @@
+export { defaultIconResolver } from "./DefaultIconResolver";
+export { defaultTooltipResolver } from "./DefaultTooltipResolver";

package/dist/collection/components/ez-tree/types/Node.js

@@ -0,0 +1,110 @@
+export class Node {
+  constructor(tree, item, parent, isPlaceHolder = false) {
+    this.children = new Map();
+    this.visible = true;
+    this.item = item;
+    this.parent = parent;
+    this._tree = tree;
+    this.isPlaceHolder = isPlaceHolder;
+    if (item && !isPlaceHolder) {
+      this._isLazyLoad = typeof item.children === "function" || item.childrenCount > 0;
+      if (Array.isArray(item.children)) {
+        Array.from(item.children).forEach(item => this.addChild(this._tree, item));
+        this._childrenLoaded = true;
+      }
+    }
+    else {
+      this._isLazyLoad = false;
+      this._childrenLoaded = true;
+    }
+  }
+  refresh(newItem) {
+    if (this.isPlaceHolder) {
+      return;
+    }
+    this.item = Object.assign({}, newItem);
+    this._isLazyLoad = typeof this.item.children === "function" || this.item.childrenCount > 0;
+    const oldChildren = this.children;
+    this.children = new Map();
+    if (Array.isArray(this.item.children)) {
+      if (this.item.expanded === undefined) {
+        this.item.expanded = true;
+      }
+      Array.from(this.item.children).forEach(item => {
+        const node = oldChildren.get(item.id);
+        if (node) {
+          if (item.expanded === undefined) {
+            item.expanded = node.item.expanded;
+          }
+          node.refresh(item);
+          this.children.set(item.id, node);
+        }
+        else {
+          if (item.expanded === undefined) {
+            item.expanded = true;
+          }
+          this.addChild(this._tree, Object.assign({}, item));
+        }
+      });
+      this._childrenLoaded = true;
+    }
+    else {
+      this._childrenLoaded = false;
+    }
+  }
+  isDisabled() {
+    if (this.isPlaceHolder) {
+      return false;
+    }
+    return this._tree.isNodeDisabled(this.item.id, this.item.disabled);
+  }
+  updateChildren(children) {
+    if (this.isPlaceHolder) {
+      return;
+    }
+    this.refresh(Object.assign(Object.assign({}, this.item), { children }));
+  }
+  addChild(tree, item) {
+    if (!this.children.has(item.id)) {
+      this.children.set(item.id, new Node(tree, item, this));
+    }
+  }
+  addPlaceHolder() {
+    this.children.clear();
+    const id = this.item.id;
+    this.children.set(id, new Node(undefined, { id: `placeholder_${id}`, label: "Carregando..." }, this, true));
+  }
+  getNode(id) {
+    if (this.children.has(id)) {
+      return this.children.get(id);
+    }
+    const childrenArray = Array.from(this.children.values());
+    for (const child of childrenArray) {
+      const result = child.getNode(id);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  needLoad() {
+    return this._isLazyLoad && !this._childrenLoaded;
+  }
+  isExpandable() {
+    if (this._isLazyLoad) {
+      return true;
+    }
+    if (this.children.size > 0) {
+      return true;
+    }
+    return false;
+  }
+  getChildren() {
+    if (this.isPlaceHolder) {
+      return [];
+    }
+    if (this.needLoad()) {
+      this._tree.loadChildren(this);
+    }
+    return Array.from(this.children.values());
+  }
+}

package/dist/collection/components/ez-tree/types/Tree.js

@@ -0,0 +1,132 @@
+import { StringUtils } from "@sankhyalabs/core";
+import { Node } from "./Node";
+export class Tree extends Node {
+  constructor(changeCallback) {
+    super(undefined);
+    this._disabledValues = new Map();
+    this._changeCallback = changeCallback;
+  }
+  async addChildAt(parentId, item) {
+    const parent = this.getNode(parentId);
+    if (parent == undefined) {
+      return;
+    }
+    parent.addChild(this, item);
+    this._changeCallback();
+  }
+  setDisabled(id, value) {
+    this._disabledValues.set(id, value);
+    this._changeCallback();
+  }
+  isNodeDisabled(id, defaultValue) {
+    if (!this._disabledValues.has(id)) {
+      return defaultValue;
+    }
+    return this._disabledValues.get(id);
+  }
+  load(items) {
+    if (items === this._currentItems) {
+      return;
+    }
+    this._currentItems = items;
+    const oldChildren = this.children;
+    this.children = new Map();
+    this._disabledValues.clear();
+    items.forEach(item => {
+      const node = oldChildren.get(item.id);
+      if (node) {
+        node.refresh(item);
+        this.children.set(item.id, node);
+      }
+      else {
+        this.addChild(this, Object.assign({}, item));
+      }
+    });
+  }
+  setFilterPattern(pattern) {
+    this._filterPattern = StringUtils.replaceAccentuatedCharsKeepSymbols(pattern);
+    this.applyFilter(this);
+    this._changeCallback();
+  }
+  updateItem(item) {
+    if (item == undefined) {
+      return;
+    }
+    const node = this.getNode(item.id);
+    if (node == undefined) {
+      return;
+    }
+    Object.keys(item).forEach(attrib => node.item[attrib] = item[attrib]);
+    if (item.children == undefined) {
+      node.children.clear();
+    }
+    else if (Array.isArray(item.children)) {
+      node.updateChildren(item.children);
+    }
+    this._changeCallback();
+  }
+  async open(path) {
+    return new Promise(async (resolve) => {
+      await this.walkPath(this, path, node => node.item.expanded = true);
+      resolve();
+    });
+  }
+  applyFilter(node) {
+    node.children.forEach((value) => {
+      this.applyFilter(value);
+    });
+    if (node.item == undefined) {
+      return;
+    }
+    const normalizedLabel = StringUtils.replaceAccentuatedCharsKeepSymbols(node.item.label);
+    let isVisible = false;
+    if (normalizedLabel.includes(this._filterPattern)) {
+      isVisible = true;
+    }
+    else {
+      const childrenArray = Array.from(node.children.values());
+      for (let i = 0; i < childrenArray.length; i++) {
+        if (childrenArray[i].visible) {
+          isVisible = true;
+          node.item.expanded = true;
+          break;
+        }
+      }
+    }
+    node.visible = isVisible;
+  }
+  async walkPath(parent, path, callback, currentLevel = 0) {
+    return new Promise(async (resolve) => {
+      const levels = path.split(">>").map(item => item.trim());
+      if (levels.length > currentLevel) {
+        const node = parent.getNode(levels[currentLevel]);
+        if (node) {
+          if (node.needLoad()) {
+            await this.loadLevel(node);
+          }
+          callback(node);
+          await this.walkPath(node, path, callback, currentLevel + 1);
+        }
+      }
+      resolve();
+    });
+  }
+  async loadChildren(node) {
+    return new Promise(resolve => {
+      this.loadLevel(node).then(() => {
+        resolve();
+        this._changeCallback();
+      });
+    });
+  }
+  async loadLevel(node) {
+    return new Promise(resolve => {
+      node.addPlaceHolder();
+      const loader = node.item.children;
+      loader(node.item).then(result => {
+        node.updateChildren(result);
+        resolve();
+      });
+    });
+  }
+}

package/dist/collection/components/ez-upload/RemoteFile.js

@@ -0,0 +1,94 @@
+export default class RemoteFile {
+  constructor(file) {
+    this.file = file;
+    this.size = file.size;
+    this.name = file.name;
+  }
+  abortUpload() {
+    if (this._uploadingXhr) {
+      this._aborted = true;
+      this._uploadingXhr.abort();
+      this._uploadingXhr = undefined;
+    }
+  }
+  isUploading() {
+    return this._uploadingXhr !== undefined;
+  }
+  async upload(server, headers, updateCallBack) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      this._uploadingXhr = xhr;
+      this._aborted = false;
+      this.progress = 0;
+      xhr.upload.onprogress = (e) => {
+        const loaded = e.loaded;
+        const total = e.total;
+        this.progress = ~~((loaded / total) * 100);
+        updateCallBack(this, loaded, total);
+      };
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState == 4) {
+          this._uploadingXhr = undefined;
+          const status = xhr.status;
+          if (!this._aborted) {
+            if (status === 0) {
+              reject("Servidor indisponível");
+            }
+            else if (status >= 500) {
+              reject("Erro inesperado no servidor");
+            }
+            else if (status >= 400) {
+              reject("Operação não permitida");
+            }
+          }
+          const response = xhr.response;
+          if (response) {
+            try {
+              resolve(JSON.parse(response));
+            }
+            catch (error) {
+              reject(`Servidor não retornou um objeto válido: ${response}.\n${error}`);
+            }
+          }
+        }
+      };
+      xhr.ontimeout = () => {
+        reject("Tempo limite de transferência atingido.");
+      };
+      const formData = new FormData();
+      formData.append("ARQUIVO", this.file, this.file.name);
+      xhr.open("POST", server, true);
+      if (headers) {
+        headers.forEach((value, key) => xhr.setRequestHeader(key, value));
+      }
+      xhr.send(formData);
+    });
+  }
+  async delete(item, server, headers) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState == 4) {
+          if (xhr.status === 0) {
+            reject("Servidor indisponível");
+          }
+          else if (xhr.status >= 500) {
+            reject("Erro inesperado no servidor");
+          }
+          else if (xhr.status >= 400) {
+            reject("Operação não permitida");
+          }
+          resolve(true);
+        }
+      };
+      xhr.ontimeout = () => {
+        reject("Tempo limite de remoção atingido.");
+      };
+      xhr.open("DELETE", server, true);
+      if (headers) {
+        headers.forEach((value, key) => xhr.setRequestHeader(key, value));
+      }
+      xhr.send(JSON.stringify(item));
+    });
+  }
+}