@sumaris-net/ngx-components 18.14.0 → 18.14.2

package/esm2022/src/app/core/services/model/tree-item-entity.model.mjs

@@ -0,0 +1,220 @@
+import { EntityUtils } from './entity.model';
+import { isEmptyArray, isNil, isNotNil } from '../../../shared/functions';
+export class TreeItemEntityUtils {
+    static forward(node, filterFn, loopCount) {
+        // Stop infinite loop
+        if (loopCount === 100) {
+            console.error('Infinite loop detected! Make sure there is valid node in this tree!');
+            return undefined;
+        }
+        let indexInParent = node.parent ? (node.parent.children || []).indexOf(node) : -1;
+        // Root node
+        if (indexInParent === -1) {
+            return this.first(node, filterFn);
+        }
+        // Dive into children
+        const firstChild = (node.children || []).map((c) => this.first(c, filterFn)).find(isNotNil);
+        if (firstChild)
+            return firstChild;
+        // Lookup in brothers
+        let current = node;
+        while (current.parent && indexInParent !== -1) {
+            // Has brother ?
+            if (indexInParent + 1 < current.parent.children.length) {
+                const brother = (current.parent.children || [])
+                    .slice(indexInParent + 1)
+                    .map((c) => (!filterFn || filterFn(c) ? c : this.first(c, filterFn)))
+                    .find(isNotNil);
+                // OK, found a brother
+                if (brother)
+                    return brother;
+            }
+            // Retry, with parent's brother
+            current = current.parent;
+            indexInParent = current.parent ? (current.parent.children || []).indexOf(current) : -1;
+        }
+        // Return parent
+        if (current !== node && (!filterFn || filterFn(current)))
+            return current;
+        return this.first(current, filterFn);
+    }
+    static backward(node, filterFn, loopCount) {
+        // Stop infinite loop
+        if (loopCount === 100) {
+            console.error('Infinite loop detected! Make sure there is valid node in this tree!');
+            return undefined;
+        }
+        const indexInParent = node.parent ? (node.parent.children || []).indexOf(node) : -1;
+        // Root node
+        if (indexInParent === -1) {
+            return this.lastLeaf(node, filterFn);
+        }
+        // No previous brother (first in parent's list)
+        else if (indexInParent === 0) {
+            // Return the parent, if match
+            return !filterFn || filterFn(node.parent)
+                ? node.parent
+                : // Or recursively call backward() on the parent
+                    this.backward(node.parent, filterFn, (loopCount || 0) + 1);
+        }
+        // Lookup in brother
+        else {
+            const previousBrother = (node.parent.children || [])
+                .slice(0, indexInParent)
+                .reverse()
+                .find((c) => !filterFn || filterFn(c));
+            // OK, there is a brother before the current index
+            if (previousBrother)
+                return this.lastLeaf(previousBrother, filterFn);
+        }
+        // Not found in brother: recursively call backward() on the parent
+        return this.backward(node.parent, filterFn, (loopCount || 0) + 1);
+    }
+    static first(node, filterFn) {
+        // Node has children: dive into children
+        const child = (node.children || []).find((c) => this.first(c, filterFn));
+        if (child)
+            return child;
+        // Node match: use it
+        return !filterFn || filterFn(node) ? node : undefined;
+    }
+    static lastLeaf(node, filterFn) {
+        // Node has children: dive into children
+        const childLeaf = (node.children || [])
+            // Reverse order (after clone)
+            .slice()
+            .reverse()
+            .map((c) => this.lastLeaf(c, filterFn))
+            .find(isNotNil);
+        if (childLeaf)
+            return childLeaf; // OK, found in children
+        // Node is a leaf, or not match found in children: check current
+        return !filterFn || filterFn(node) ? node : undefined;
+    }
+    static findByFilter(node, filter) {
+        const filterFn = filter?.asFilterFn();
+        if (!filterFn)
+            throw new Error('Missing or empty filter argument');
+        return this.filterRecursively(node, filterFn);
+    }
+    /**
+     * Delete matches batches
+     *
+     * @param node
+     * @param filter
+     */
+    static deleteByFilter(node, filter) {
+        const filterFn = filter?.asFilterFn();
+        if (!filterFn)
+            throw new Error('Missing or empty filter argument');
+        return this.deleteRecursively(node, filterFn);
+    }
+    static filterRecursively(node, filterFn) {
+        return (node?.children || []).reduce((res, child) => res.concat(this.filterRecursively(child, filterFn)), 
+        // Init result
+        filterFn(node) ? [node] : []);
+    }
+    static deleteRecursively(node, filterFn) {
+        if (isEmptyArray(node.children))
+            return []; // Skip
+        // Delete children
+        const deletedChildren = node.children.filter(filterFn);
+        node.children = node.children.filter((c) => !deletedChildren.includes(c));
+        // TODO: add an options to clean the parent
+        //deletedChildren.forEach(child => child.parent = null);
+        // Recursive call, in still existing children
+        return node.children.reduce((res, c) => res.concat(...this.deleteRecursively(c, filterFn)), deletedChildren);
+    }
+    /**
+     * Visit each node, from root to leaf
+     *
+     * @param node
+     * @param action
+     */
+    static visit(node, action) {
+        if (node == null) {
+            return;
+        }
+        // Appliquer l'action sur le nœud actuel
+        action(node);
+        // Parcourir les enfants
+        if (node.children) {
+            node.children.forEach((child) => this.visit(child, action));
+        }
+    }
+    /**
+     * Visit each node, from leaf to root
+     *
+     * @param node
+     * @param action
+     */
+    static visitInverse(node, action) {
+        if (node == null) {
+            return;
+        }
+        // Parcourir les enfants
+        if (node.children) {
+            node.children.forEach((child) => this.visitInverse(child, action));
+        }
+        // Appliquer l'action sur le nœud actuel
+        action(node);
+    }
+    /**
+     * Transform a batch entity tree into a array list. This method keep links parent/children.
+     *
+     * Method used to find batch without id (e.g. before local storage)
+     *
+     * @param source
+     */
+    static treeToArray(source) {
+        if (!source)
+            return null;
+        return (source.children || []).reduce((res, batch) => {
+            batch.parent = source;
+            return res.concat(this.treeToArray(batch)); // recursive call
+        }, [source]);
+    }
+    static listOfTreeToArray(sources) {
+        if (!sources || !sources.length)
+            return null;
+        return sources.reduce((res, source) => res.concat(this.treeToArray(source)), []);
+    }
+    /**
+     * Fill parent attribute, of all children found in the tree
+     *
+     * @param source
+     */
+    static treeFillParent(source) {
+        if (!source)
+            return null;
+        (source.children || []).forEach((child) => {
+            child.parent = source;
+            this.treeFillParent(child); // Loop
+        });
+    }
+    /**
+     * Converts an array of objects into a tree hierarchy based on parent-child relationships.
+     *
+     * @param {T[]} sources - The array of source objects to be converted into tree structure.
+     * @param {new () => T} [dataType] - An optional class constructor used to shape the objects within the tree.
+     * @return {T[] | undefined} An array of root elements representing the tree structure, or undefined if the input is empty.
+     */
+    static fromObjectArrayAsTrees(sources, dataType) {
+        if (!sources)
+            return null;
+        const targets = dataType ? (sources || []).map((json) => EntityUtils.fromObject(json, dataType)) : sources;
+        const rootTargets = targets.filter((b) => isNil(b.parentId) && isNil(b.parent)) || undefined;
+        if (isEmptyArray(rootTargets))
+            return undefined;
+        targets.forEach((s) => {
+            // Link to parent
+            const parentId = s.parentId ?? s.parent?.id;
+            s.parent = (isNotNil(parentId) && targets.find((p) => p.id === parentId)) || undefined;
+            s.parentId = undefined; // Avoid redundant info on parent
+        });
+        // Link to children
+        targets.forEach((s) => (s.children = targets.filter((p) => p.parent && p.parent === s) || []));
+        return rootTargets;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-item-entity.model.js","sourceRoot":"","sources":["../../../../../../../src/app/core/services/model/tree-item-entity.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityUtils, IEntity } from './entity.model';\nimport { isEmptyArray, isNil, isNotNil } from '../../../shared/functions';\nimport { EntityFilter } from './filter.model';\nimport { FilterFn } from '../../../shared/types';\n\nexport declare interface ITreeItemEntity<T extends IEntity<T, ID>, ID = number> {\n  parentId: ID;\n  parent: T;\n  children: T[];\n}\n\nexport class TreeItemEntityUtils {\n  static forward<T extends ITreeItemEntity<any>>(node: T, filterFn?: FilterFn<T>, loopCount?: number): T {\n    // Stop infinite loop\n    if (loopCount === 100) {\n      console.error('Infinite loop detected! Make sure there is valid node in this tree!');\n      return undefined;\n    }\n\n    let indexInParent = node.parent ? (node.parent.children || []).indexOf(node) : -1;\n    // Root node\n    if (indexInParent === -1) {\n      return this.first(node, filterFn);\n    }\n\n    // Dive into children\n    const firstChild = (node.children || []).map((c) => this.first(c, filterFn)).find(isNotNil);\n    if (firstChild) return firstChild;\n\n    // Lookup in brothers\n    let current = node;\n    while (current.parent && indexInParent !== -1) {\n      // Has brother ?\n      if (indexInParent + 1 < current.parent.children.length) {\n        const brother = (current.parent.children || [])\n          .slice(indexInParent + 1)\n          .map((c) => (!filterFn || filterFn(c) ? c : this.first(c, filterFn)))\n          .find(isNotNil);\n        // OK, found a brother\n        if (brother) return brother;\n      }\n      // Retry, with parent's brother\n      current = current.parent;\n      indexInParent = current.parent ? (current.parent.children || []).indexOf(current) : -1;\n    }\n\n    // Return parent\n    if (current !== node && (!filterFn || filterFn(current))) return current;\n\n    return this.first(current, filterFn);\n  }\n\n  static backward<T extends ITreeItemEntity<any>, ID = number>(node: T, filterFn?: FilterFn<T>, loopCount?: number): T {\n    // Stop infinite loop\n    if (loopCount === 100) {\n      console.error('Infinite loop detected! Make sure there is valid node in this tree!');\n      return undefined;\n    }\n\n    const indexInParent = node.parent ? (node.parent.children || []).indexOf(node) : -1;\n    // Root node\n    if (indexInParent === -1) {\n      return this.lastLeaf(node, filterFn);\n    }\n\n    // No previous brother (first in parent's list)\n    else if (indexInParent === 0) {\n      // Return the parent, if match\n      return !filterFn || filterFn(node.parent)\n        ? node.parent\n        : // Or recursively call backward() on the parent\n          this.backward(node.parent, filterFn, (loopCount || 0) + 1);\n    }\n\n    // Lookup in brother\n    else {\n      const previousBrother = (node.parent.children || [])\n        .slice(0, indexInParent)\n        .reverse()\n        .find((c) => !filterFn || filterFn(c));\n\n      // OK, there is a brother before the current index\n      if (previousBrother) return this.lastLeaf(previousBrother, filterFn);\n    }\n\n    // Not found in brother: recursively call backward() on the parent\n    return this.backward(node.parent, filterFn, (loopCount || 0) + 1);\n  }\n\n  static first<T extends ITreeItemEntity<any>>(node: T, filterFn?: FilterFn<T>): T {\n    // Node has children: dive into children\n    const child = (node.children || []).find((c) => this.first(c, filterFn));\n    if (child) return child;\n\n    // Node match: use it\n    return !filterFn || filterFn(node) ? node : undefined;\n  }\n\n  static lastLeaf<T extends ITreeItemEntity<any>>(node: T, filterFn?: FilterFn<T>): T {\n    // Node has children: dive into children\n    const childLeaf = (node.children || [])\n      // Reverse order (after clone)\n      .slice()\n      .reverse()\n      .map((c) => this.lastLeaf(c, filterFn))\n      .find(isNotNil);\n    if (childLeaf) return childLeaf; // OK, found in children\n\n    // Node is a leaf, or not match found in children: check current\n    return !filterFn || filterFn(node) ? node : undefined;\n  }\n\n  static findByFilter<T extends ITreeItemEntity<T> & IEntity<T>>(node: T, filter: EntityFilter<any, T>): T[] {\n    const filterFn = filter?.asFilterFn();\n    if (!filterFn) throw new Error('Missing or empty filter argument');\n\n    return this.filterRecursively(node, filterFn);\n  }\n\n  /**\n   * Delete matches batches\n   *\n   * @param node\n   * @param filter\n   */\n  static deleteByFilter<T extends ITreeItemEntity<T> & IEntity<T>>(node: T, filter: EntityFilter<any, T>): T[] {\n    const filterFn = filter?.asFilterFn();\n    if (!filterFn) throw new Error('Missing or empty filter argument');\n\n    return this.deleteRecursively(node, filterFn);\n  }\n\n  static filterRecursively<T extends ITreeItemEntity<any>>(node: T, filterFn: (n: T) => boolean): T[] {\n    return (node?.children || []).reduce(\n      (res, child) => res.concat(this.filterRecursively(child, filterFn)),\n      // Init result\n      filterFn(node) ? [node] : []\n    );\n  }\n\n  static deleteRecursively<T extends ITreeItemEntity<any>>(node: T, filterFn: (n: T) => boolean): T[] {\n    if (isEmptyArray(node.children)) return []; // Skip\n\n    // Delete children\n    const deletedChildren = node.children.filter(filterFn);\n    node.children = node.children.filter((c) => !deletedChildren.includes(c));\n\n    // TODO: add an options to clean the parent\n    //deletedChildren.forEach(child => child.parent = null);\n\n    // Recursive call, in still existing children\n    return node.children.reduce((res, c) => res.concat(...this.deleteRecursively(c, filterFn)), deletedChildren);\n  }\n\n  /**\n   * Visit each node, from root to leaf\n   *\n   * @param node\n   * @param action\n   */\n  static visit<T extends ITreeItemEntity<any>>(node: T, action: (item: T) => void) {\n    if (node == null) {\n      return;\n    }\n\n    // Appliquer l'action sur le nœud actuel\n    action(node);\n\n    // Parcourir les enfants\n    if (node.children) {\n      node.children.forEach((child) => this.visit(child, action));\n    }\n  }\n\n  /**\n   * Visit each node, from leaf to root\n   *\n   * @param node\n   * @param action\n   */\n  static visitInverse<T extends ITreeItemEntity<any>>(node: T, action: (T) => void) {\n    if (node == null) {\n      return;\n    }\n\n    // Parcourir les enfants\n    if (node.children) {\n      node.children.forEach((child) => this.visitInverse(child, action));\n    }\n\n    // Appliquer l'action sur le nœud actuel\n    action(node);\n  }\n\n  /**\n   * Transform a batch entity tree into a array list. This method keep links parent/children.\n   *\n   * Method used to find batch without id (e.g. before local storage)\n   *\n   * @param source\n   */\n  static treeToArray<T extends ITreeItemEntity<any>>(source: T): T[] {\n    if (!source) return null;\n    return (source.children || []).reduce(\n      (res, batch) => {\n        batch.parent = source;\n        return res.concat(this.treeToArray(batch)); // recursive call\n      },\n      [source]\n    );\n  }\n\n  static listOfTreeToArray<T extends ITreeItemEntity<any>>(sources: T[]): T[] {\n    if (!sources || !sources.length) return null;\n    return sources.reduce((res, source) => res.concat(this.treeToArray<T>(source)), []);\n  }\n\n  /**\n   * Fill parent attribute, of all children found in the tree\n   *\n   * @param source\n   */\n  static treeFillParent<T extends ITreeItemEntity<any>>(source: T) {\n    if (!source) return null;\n    (source.children || []).forEach((child) => {\n      child.parent = source;\n      this.treeFillParent(child); // Loop\n    });\n  }\n\n  /**\n   * Converts an array of objects into a tree hierarchy based on parent-child relationships.\n   *\n   * @param {T[]} sources - The array of source objects to be converted into tree structure.\n   * @param {new () => T} [dataType] - An optional class constructor used to shape the objects within the tree.\n   * @return {T[] | undefined} An array of root elements representing the tree structure, or undefined if the input is empty.\n   */\n  static fromObjectArrayAsTrees<T extends ITreeItemEntity<T> & IEntity<T>>(sources: T[], dataType?: new () => T): T[] {\n    if (!sources) return null;\n    const targets = dataType ? (sources || []).map((json) => EntityUtils.fromObject<T>(json, dataType)) : sources;\n    const rootTargets = targets.filter((b) => isNil(b.parentId) && isNil(b.parent)) || undefined;\n    if (isEmptyArray(rootTargets)) return undefined;\n\n    targets.forEach((s) => {\n      // Link to parent\n      const parentId = s.parentId ?? s.parent?.id;\n      s.parent = (isNotNil(parentId) && targets.find((p) => p.id === parentId)) || undefined;\n      s.parentId = undefined; // Avoid redundant info on parent\n    });\n\n    // Link to children\n    targets.forEach((s) => (s.children = targets.filter((p) => p.parent && p.parent === s) || []));\n\n    return rootTargets;\n  }\n}\n"]}