@sankhyalabs/ezui 2.7.6 → 2.9.0

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

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

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

@@ -0,0 +1,72 @@
+export class Node {
+  constructor(tree, item, parent, isPlaceHolder = false) {
+    this.children = new Map();
+    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;
+    }
+  }
+  isDisabled() {
+    if (this.isPlaceHolder) {
+      return false;
+    }
+    return this._tree.isNodeDisabled(this.item.id, this.item.disabled);
+  }
+  updateChildren(children) {
+    if (this.isPlaceHolder) {
+      return;
+    }
+    this.item.children = children;
+    this._childrenLoaded = true;
+    this.children.clear();
+    children.forEach(item => this.addChild(this._tree, Object.assign({}, item)));
+  }
+  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() {
+    return this._isLazyLoad || this.children.size > 0 || Array.isArray(this.item.children);
+  }
+  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,70 @@
+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) {
+    this.children.clear();
+    items.forEach(item => this.addChild(this, Object.assign({}, item)));
+  }
+  async open(path) {
+    return new Promise(async (resolve) => {
+      await this.walk(this, path, node => node.item.expanded = true);
+      resolve();
+    });
+  }
+  async walk(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.walk(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/custom-elements/index.d.ts

@@ -20,6 +20,12 @@ export const EzApplication: {
   new (): EzApplication;
 };
 
+interface EzBreadcrumb extends Components.EzBreadcrumb, HTMLElement {}
+export const EzBreadcrumb: {
+  prototype: EzBreadcrumb;
+  new (): EzBreadcrumb;
+};
+
 interface EzButton extends Components.EzButton, HTMLElement {}
 export const EzButton: {
   prototype: EzButton;
@@ -206,6 +212,12 @@ export const EzToast: {
   new (): EzToast;
 };
 
+interface EzTree extends Components.EzTree, HTMLElement {}
+export const EzTree: {
+  prototype: EzTree;
+  new (): EzTree;
+};
+
 interface EzUpload extends Components.EzUpload, HTMLElement {}
 export const EzUpload: {
   prototype: EzUpload;