ngx-register-base 1.3.1 → 1.3.3

package/esm2022/lib/components/inputs/param-tree/param-tree.component.mjs

@@ -0,0 +1,207 @@
+import { ChangeDetectionStrategy, Component, computed, DestroyRef, effect, inject, input, output, untracked, } from '@angular/core';
+import { TuiCheckbox, TuiTree } from '@taiga-ui/kit';
+import { TuiLabel, TuiLoader } from '@taiga-ui/core';
+import { FormsModule } from '@angular/forms';
+import { AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { EMPTY, expand, filter, from, of, switchMap, take, takeUntil, tap } from 'rxjs';
+import { ParamTreeService } from './services/param-tree.service';
+import { TREE_LOADING_NODE, treeNodesFlatten, updatesCheckedNodesEqual, } from './consts/param-tree.consts';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/kit";
+import * as i2 from "@angular/forms";
+/** Компонент иерархического списка */
+export class ParamTreeComponent {
+    constructor() {
+        /**
+         * Режим выбора нескольких значений
+         *
+         * @default Выбор единственного узла */
+        this.multi = input(false);
+        /** Задать выбранные узлы */
+        this.checkedNodes = input([]);
+        /** Кастомный шаблон узла */
+        this.nodeTemplate = input(null);
+        /** Выбранные узлы верхнего уровня */
+        this.selectedNodesChange = output();
+        this._treeService = inject((ParamTreeService));
+        this._dr = inject(DestroyRef);
+        this.defaultNodeOpenedState = toSignal(this._treeService.defaultNodeOpenedState$);
+        this.openedNodesState = this._treeService.openedNodesState;
+        this.checkedNodesState = this._treeService.checkedNodesState;
+        this._lastCheckedNode = toSignal(this._treeService.lastCheckedNode$, {
+            initialValue: null,
+        });
+        this.updatesCheckedNodes = computed(() => this.checkedNodes(), {
+            equal: (prev, curr) => updatesCheckedNodesEqual(prev, curr, this._treeService),
+        });
+        this.treeNodes$ = this._treeService.nodes$;
+        this.TREE_LOADER = TREE_LOADING_NODE;
+        this.childrenHandler = (node) => this._treeService.getChildren(node);
+        this.onChecked = (currentNode, check) => {
+            this._treeService.setLastCheckedNode(check ? currentNode : null);
+            const flattenNodes = treeNodesFlatten(currentNode, this._treeService);
+            if (this.multi()) {
+                for (const node of flattenNodes) {
+                    this.checkedNodesState().set(node, check);
+                }
+            }
+            else {
+                this.checkedNodesState().clear();
+                for (const node of flattenNodes) {
+                    this.checkedNodesState().set(node, true);
+                }
+            }
+            this._updateCheckedNodes();
+        };
+        effect(() => {
+            const nodes = this.updatesCheckedNodes();
+            untracked(() => {
+                if (nodes.length === 0) {
+                    this.checkedNodesState.set(new Map());
+                }
+                else {
+                    this._tryToSetNodesRecursive(nodes);
+                }
+            });
+        });
+    }
+    getValue(currentNode, state) {
+        return this.multi()
+            ? this._isSelectedMulti(currentNode, state)
+            : this._isSelectedSingle(currentNode, state);
+    }
+    _isSelectedMulti(currentNode, state) {
+        let result = null;
+        const flattenNodes = treeNodesFlatten(currentNode, this._treeService);
+        const firstNode = flattenNodes[0];
+        if (firstNode) {
+            result = !!state.get(firstNode);
+        }
+        for (const node of flattenNodes) {
+            if (result !== !!state.get(node)) {
+                const currentLevelNode = flattenNodes.filter((value) => value.parent === node.parent);
+                return currentLevelNode.every((value) => !!state.get(value)) ? true : null;
+            }
+        }
+        return result;
+    }
+    _isSelectedSingle(currentNode, state) {
+        const lastNode = this._lastCheckedNode();
+        const flattenNodes = treeNodesFlatten(currentNode, this._treeService);
+        const isLinkedNode = flattenNodes.some((node) => !!state.get(node));
+        if (!isLinkedNode || !lastNode) {
+            return false;
+        }
+        return lastNode === currentNode ||
+            this._isDeepParent(currentNode, lastNode) ||
+            this._isDeepChild(currentNode, lastNode)
+            ? true
+            : null;
+    }
+    _isDeepParent(parent, child) {
+        if (!child.parent) {
+            return false;
+        }
+        if (parent === child.parent && parent.children.length === 1) {
+            return true;
+        }
+        if (child.parent.children && child.parent.children.length !== 1) {
+            return false;
+        }
+        return this._isDeepParent(parent, child.parent);
+    }
+    _isDeepChild(child, parent) {
+        if (!parent.children || parent.children.length === 0) {
+            return false;
+        }
+        for (const node of parent.children) {
+            if (node === child) {
+                return true;
+            }
+            if (this._isDeepChild(child, node)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    onToggle(currentNode) {
+        this._treeService
+            .loadChildren(currentNode)
+            .pipe(takeUntilDestroyed(this._dr))
+            .subscribe((children) => {
+            const parent = children?.[0]?.parent;
+            if (parent && this.checkedNodesState().get(parent)) {
+                for (const child of children) {
+                    this.checkedNodesState().set(child, true);
+                }
+            }
+        });
+    }
+    _updateCheckedNodes(options) {
+        const topLevelNodes = this._treeService.getTopLevelNodes();
+        const state = new Map();
+        this._calcCheckedStateNodes(topLevelNodes, state);
+        this.checkedNodesState.set(state);
+        if (options?.emitEvent !== false) {
+            this.selectedNodesChange.emit(this._findFullySelectedNodes(topLevelNodes));
+        }
+    }
+    _findFullySelectedNodes(nodes) {
+        const fullySelectedNodes = [];
+        for (const node of nodes) {
+            const checked = this.getValue(node, this.checkedNodesState());
+            if (checked) {
+                fullySelectedNodes.push(node);
+            }
+            else if (checked === null) {
+                const children = this._treeService.getChildren(node);
+                const fullySelectedChildren = this._findFullySelectedNodes(children);
+                fullySelectedNodes.push(...fullySelectedChildren);
+            }
+        }
+        return fullySelectedNodes;
+    }
+    _calcCheckedStateNodes(nodes, state) {
+        for (const node of nodes) {
+            const checked = this.getValue(node, this.checkedNodesState());
+            if (checked !== false) {
+                state.set(node, checked);
+                const children = this._treeService.getChildren(node);
+                this._calcCheckedStateNodes(children, state);
+            }
+        }
+    }
+    _tryToSetNodesRecursive(newNodes) {
+        const topLevelNodes = this._treeService.getTopLevelNodes();
+        const searchNodesCompleteState = new Map(newNodes.map((newNode) => [newNode, false]));
+        const allComplete = (state) => [...state.values()].every(Boolean);
+        const analogNodes = [];
+        from(topLevelNodes)
+            .pipe(expand((node) => this._treeService.hasChildren(node)
+            ? this._treeService.loadChildren(node).pipe(switchMap((children) => from(children)))
+            : EMPTY), tap((node) => {
+            const foundNode = newNodes.find((newNode) => this._treeService.equals(node, newNode));
+            if (foundNode) {
+                searchNodesCompleteState.set(foundNode, true);
+                analogNodes.push(node);
+            }
+        }), filter(() => allComplete(searchNodesCompleteState)), take(1), 
+        // eslint-disable-next-line rxjs/no-unsafe-takeuntil
+        takeUntil(of(null).pipe(filter(() => allComplete(searchNodesCompleteState)))), takeUntilDestroyed(this._dr))
+            .subscribe({
+            complete: () => {
+                for (const node of analogNodes) {
+                    this.onChecked(node, true);
+                }
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTreeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ParamTreeComponent, isStandalone: true, selector: "sproc-param-tree", inputs: { multi: { classPropertyName: "multi", publicName: "multi", isSignal: true, isRequired: false, transformFunction: null }, checkedNodes: { classPropertyName: "checkedNodes", publicName: "checkedNodes", isSignal: true, isRequired: false, transformFunction: null }, nodeTemplate: { classPropertyName: "nodeTemplate", publicName: "nodeTemplate", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selectedNodesChange: "selectedNodesChange" }, ngImport: i0, template: "<div class=\"tree-custom-class__container\">\n  @for (node of treeNodes$ | async; track node) {\n    @if (node === TREE_LOADER) {\n      <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n    } @else {\n      @if (defaultNodeOpenedState() === undefined) {\n        <tui-tree\n          class=\"tui_tree--not-collapsed\"\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n        >\n        </tui-tree>\n      } @else {\n        <tui-tree\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n          [tuiTreeController]=\"!!defaultNodeOpenedState()\"\n          [map]=\"openedNodesState()\"\n          (toggled)=\"onToggle($event)\"\n        >\n        </tui-tree>\n      }\n    }\n  }\n</div>\n\n<ng-template #contentTemplate let-node>\n  @let isChecked = checkedNodesState().get(node);\n\n  @if (node === TREE_LOADER) {\n    <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n  } @else if (nodeTemplate()) {\n    <ng-container\n      [ngTemplateOutlet]=\"nodeTemplate()\"\n      [ngTemplateOutletContext]=\"{ node, isChecked, onChecked }\"\n    ></ng-container>\n  } @else {\n    <label tuiLabel class=\"tree-custom-class__label-checkbox-container\">\n      <input\n        size=\"s\"\n        tuiCheckbox\n        type=\"checkbox\"\n        [ngModel]=\"isChecked\"\n        (ngModelChange)=\"onChecked(node, $event)\"\n      />\n      <small>{{ node.name }}</small>\n    </label>\n  }\n</ng-template>\n", styles: [".tree-custom-class__label-checkbox-container{margin-inline-start:4px}\n"], dependencies: [{ kind: "component", type: i1.TuiTreeComponent, selector: "tui-tree", inputs: ["value", "trackBy", "content"] }, { kind: "directive", type: i1.TuiTreeChildren, selector: "tui-tree[childrenHandler]", inputs: ["childrenHandler"] }, { kind: "directive", type: i1.TuiTreeControllerDirective, selector: "[tuiTreeController][map]", inputs: ["tuiTreeController", "map"], outputs: ["toggled"], exportAs: ["tuiTreeController"] }, { kind: "directive", type: TuiLabel, selector: "label[tuiLabel]" }, { kind: "component", type: TuiCheckbox, selector: "input[type=\"checkbox\"][tuiCheckbox]", inputs: ["size"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "component", type: TuiLoader, selector: "tui-loader", inputs: ["size", "inheritColor", "overlay", "textContent", "showLoader"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sproc-param-tree', standalone: true, imports: [TuiTree, TuiLabel, TuiCheckbox, FormsModule, AsyncPipe, TuiLoader, NgTemplateOutlet], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"tree-custom-class__container\">\n  @for (node of treeNodes$ | async; track node) {\n    @if (node === TREE_LOADER) {\n      <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n    } @else {\n      @if (defaultNodeOpenedState() === undefined) {\n        <tui-tree\n          class=\"tui_tree--not-collapsed\"\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n        >\n        </tui-tree>\n      } @else {\n        <tui-tree\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n          [tuiTreeController]=\"!!defaultNodeOpenedState()\"\n          [map]=\"openedNodesState()\"\n          (toggled)=\"onToggle($event)\"\n        >\n        </tui-tree>\n      }\n    }\n  }\n</div>\n\n<ng-template #contentTemplate let-node>\n  @let isChecked = checkedNodesState().get(node);\n\n  @if (node === TREE_LOADER) {\n    <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n  } @else if (nodeTemplate()) {\n    <ng-container\n      [ngTemplateOutlet]=\"nodeTemplate()\"\n      [ngTemplateOutletContext]=\"{ node, isChecked, onChecked }\"\n    ></ng-container>\n  } @else {\n    <label tuiLabel class=\"tree-custom-class__label-checkbox-container\">\n      <input\n        size=\"s\"\n        tuiCheckbox\n        type=\"checkbox\"\n        [ngModel]=\"isChecked\"\n        (ngModelChange)=\"onChecked(node, $event)\"\n      />\n      <small>{{ node.name }}</small>\n    </label>\n  }\n</ng-template>\n", styles: [".tree-custom-class__label-checkbox-container{margin-inline-start:4px}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-tree.component.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-register-base/src/lib/components/inputs/param-tree/param-tree.component.ts","../../../../../../../projects/ngx-register-base/src/lib/components/inputs/param-tree/param-tree.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  computed,\n  DestroyRef,\n  effect,\n  inject,\n  input,\n  output,\n  TemplateRef,\n  untracked,\n} from '@angular/core';\nimport { TuiCheckbox, TuiTree } from '@taiga-ui/kit';\nimport { TuiLabel, TuiLoader } from '@taiga-ui/core';\nimport { FormsModule } from '@angular/forms';\nimport { AsyncPipe, NgTemplateOutlet } from '@angular/common';\nimport { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';\nimport { EMPTY, expand, filter, from, of, switchMap, take, takeUntil, tap } from 'rxjs';\nimport { ChildrenHandlerType, ITreeNode } from './types/param-tree.types';\nimport { ParamTreeService } from './services/param-tree.service';\nimport {\n  TREE_LOADING_NODE,\n  treeNodesFlatten,\n  updatesCheckedNodesEqual,\n} from './consts/param-tree.consts';\n\n/** Компонент иерархического списка */\n@Component({\n  selector: 'sproc-param-tree',\n  standalone: true,\n  imports: [TuiTree, TuiLabel, TuiCheckbox, FormsModule, AsyncPipe, TuiLoader, NgTemplateOutlet],\n  templateUrl: './param-tree.component.html',\n  styleUrl: './param-tree.component.less',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ParamTreeComponent<T> {\n  /**\n   * Режим выбора нескольких значений\n   *\n   * @default Выбор единственного узла */\n  public multi = input(false);\n  /** Задать выбранные узлы */\n  public checkedNodes = input<ITreeNode<T>[]>([]);\n  /** Кастомный шаблон узла */\n  public nodeTemplate = input<TemplateRef<any> | null>(null);\n\n  /** Выбранные узлы верхнего уровня */\n  public readonly selectedNodesChange = output<ITreeNode<T>[]>();\n\n  private readonly _treeService = inject(ParamTreeService<T>);\n  private readonly _dr = inject(DestroyRef);\n\n  protected readonly defaultNodeOpenedState = toSignal(this._treeService.defaultNodeOpenedState$);\n  protected readonly openedNodesState = this._treeService.openedNodesState;\n  protected readonly checkedNodesState = this._treeService.checkedNodesState;\n\n  private readonly _lastCheckedNode = toSignal(this._treeService.lastCheckedNode$, {\n    initialValue: null,\n  });\n  private readonly updatesCheckedNodes = computed(() => this.checkedNodes(), {\n    equal: (prev, curr) => updatesCheckedNodesEqual(prev, curr, this._treeService),\n  });\n\n  protected readonly treeNodes$ = this._treeService.nodes$;\n\n  protected readonly TREE_LOADER = TREE_LOADING_NODE;\n  protected readonly childrenHandler: ChildrenHandlerType<T> = (node) =>\n    this._treeService.getChildren(node);\n\n  constructor() {\n    effect(() => {\n      const nodes = this.updatesCheckedNodes();\n\n      untracked(() => {\n        if (nodes.length === 0) {\n          this.checkedNodesState.set(new Map<ITreeNode<T>, boolean | null>());\n        } else {\n          this._tryToSetNodesRecursive(nodes);\n        }\n      });\n    });\n  }\n\n  protected getValue(\n    currentNode: ITreeNode<T>,\n    state: Map<ITreeNode<T>, boolean | null>\n  ): boolean | null {\n    return this.multi()\n      ? this._isSelectedMulti(currentNode, state)\n      : this._isSelectedSingle(currentNode, state);\n  }\n\n  private _isSelectedMulti(\n    currentNode: ITreeNode<T>,\n    state: Map<ITreeNode<T>, boolean | null>\n  ): boolean | null {\n    let result: boolean | null = null;\n    const flattenNodes = treeNodesFlatten<T>(currentNode, this._treeService);\n    const firstNode = flattenNodes[0];\n\n    if (firstNode) {\n      result = !!state.get(firstNode);\n    }\n\n    for (const node of flattenNodes) {\n      if (result !== !!state.get(node)) {\n        const currentLevelNode = flattenNodes.filter((value) => value.parent === node.parent);\n\n        return currentLevelNode.every((value) => !!state.get(value)) ? true : null;\n      }\n    }\n\n    return result;\n  }\n\n  private _isSelectedSingle(\n    currentNode: ITreeNode<T>,\n    state: Map<ITreeNode<T>, boolean | null>\n  ): boolean | null {\n    const lastNode = this._lastCheckedNode();\n    const flattenNodes = treeNodesFlatten<T>(currentNode, this._treeService);\n    const isLinkedNode = flattenNodes.some((node) => !!state.get(node));\n\n    if (!isLinkedNode || !lastNode) {\n      return false;\n    }\n\n    return lastNode === currentNode ||\n      this._isDeepParent(currentNode, lastNode) ||\n      this._isDeepChild(currentNode, lastNode)\n      ? true\n      : null;\n  }\n\n  private _isDeepParent(parent: ITreeNode<T>, child: ITreeNode<T>): boolean {\n    if (!child.parent) {\n      return false;\n    }\n\n    if (parent === child.parent && parent.children!.length === 1) {\n      return true;\n    }\n\n    if (child.parent.children && child.parent.children.length !== 1) {\n      return false;\n    }\n\n    return this._isDeepParent(parent, child.parent);\n  }\n\n  private _isDeepChild(child: ITreeNode<T>, parent: ITreeNode<T>): boolean {\n    if (!parent.children || parent.children.length === 0) {\n      return false;\n    }\n\n    for (const node of parent.children) {\n      if (node === child) {\n        return true;\n      }\n\n      if (this._isDeepChild(child, node)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  protected onToggle(currentNode: ITreeNode<T>): void {\n    this._treeService\n      .loadChildren(currentNode)\n      .pipe(takeUntilDestroyed(this._dr))\n      .subscribe((children) => {\n        const parent = children?.[0]?.parent;\n\n        if (parent && this.checkedNodesState().get(parent)) {\n          for (const child of children) {\n            this.checkedNodesState().set(child, true);\n          }\n        }\n      });\n  }\n\n  protected onChecked = (currentNode: ITreeNode<T>, check: boolean) => {\n    this._treeService.setLastCheckedNode(check ? currentNode : null);\n    const flattenNodes = treeNodesFlatten<T>(currentNode, this._treeService);\n\n    if (this.multi()) {\n      for (const node of flattenNodes) {\n        this.checkedNodesState().set(node, check);\n      }\n    } else {\n      this.checkedNodesState().clear();\n\n      for (const node of flattenNodes) {\n        this.checkedNodesState().set(node, true);\n      }\n    }\n\n    this._updateCheckedNodes();\n  };\n\n  private _updateCheckedNodes(options?: { emitEvent: boolean }): void {\n    const topLevelNodes = this._treeService.getTopLevelNodes();\n    const state = new Map<ITreeNode<T>, boolean | null>();\n    this._calcCheckedStateNodes(topLevelNodes, state);\n    this.checkedNodesState.set(state);\n\n    if (options?.emitEvent !== false) {\n      this.selectedNodesChange.emit(this._findFullySelectedNodes(topLevelNodes));\n    }\n  }\n\n  private _findFullySelectedNodes(nodes: ITreeNode<T>[]): ITreeNode<T>[] {\n    const fullySelectedNodes: ITreeNode<T>[] = [];\n\n    for (const node of nodes) {\n      const checked = this.getValue(node, this.checkedNodesState());\n\n      if (checked) {\n        fullySelectedNodes.push(node);\n      } else if (checked === null) {\n        const children = this._treeService.getChildren(node);\n        const fullySelectedChildren = this._findFullySelectedNodes(children);\n        fullySelectedNodes.push(...fullySelectedChildren);\n      }\n    }\n\n    return fullySelectedNodes;\n  }\n\n  private _calcCheckedStateNodes(\n    nodes: ITreeNode<T>[],\n    state: Map<ITreeNode<T>, boolean | null>\n  ): void {\n    for (const node of nodes) {\n      const checked = this.getValue(node, this.checkedNodesState());\n\n      if (checked !== false) {\n        state.set(node, checked);\n        const children = this._treeService.getChildren(node);\n        this._calcCheckedStateNodes(children, state);\n      }\n    }\n  }\n\n  private _tryToSetNodesRecursive(newNodes: ITreeNode<T>[]): void {\n    const topLevelNodes = this._treeService.getTopLevelNodes();\n    const searchNodesCompleteState = new Map(newNodes.map((newNode) => [newNode, false]));\n    const allComplete = (state: Map<ITreeNode<T>, boolean>) => [...state.values()].every(Boolean);\n    const analogNodes: ITreeNode<T>[] = [];\n\n    from(topLevelNodes)\n      .pipe(\n        expand((node) =>\n          this._treeService.hasChildren(node)\n            ? this._treeService.loadChildren(node).pipe(switchMap((children) => from(children)))\n            : EMPTY\n        ),\n        tap((node) => {\n          const foundNode = newNodes.find((newNode) => this._treeService.equals(node, newNode));\n\n          if (foundNode) {\n            searchNodesCompleteState.set(foundNode, true);\n            analogNodes.push(node);\n          }\n        }),\n        filter(() => allComplete(searchNodesCompleteState)),\n        take(1),\n        // eslint-disable-next-line rxjs/no-unsafe-takeuntil\n        takeUntil(of(null).pipe(filter(() => allComplete(searchNodesCompleteState)))),\n        takeUntilDestroyed(this._dr)\n      )\n      .subscribe({\n        complete: () => {\n          for (const node of analogNodes) {\n            this.onChecked(node, true);\n          }\n        },\n      });\n  }\n}\n","<div class=\"tree-custom-class__container\">\n  @for (node of treeNodes$ | async; track node) {\n    @if (node === TREE_LOADER) {\n      <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n    } @else {\n      @if (defaultNodeOpenedState() === undefined) {\n        <tui-tree\n          class=\"tui_tree--not-collapsed\"\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n        >\n        </tui-tree>\n      } @else {\n        <tui-tree\n          [value]=\"node\"\n          [content]=\"contentTemplate\"\n          [childrenHandler]=\"childrenHandler\"\n          [tuiTreeController]=\"!!defaultNodeOpenedState()\"\n          [map]=\"openedNodesState()\"\n          (toggled)=\"onToggle($event)\"\n        >\n        </tui-tree>\n      }\n    }\n  }\n</div>\n\n<ng-template #contentTemplate let-node>\n  @let isChecked = checkedNodesState().get(node);\n\n  @if (node === TREE_LOADER) {\n    <tui-loader [showLoader]=\"true\" [overlay]=\"true\" size=\"s\"></tui-loader>\n  } @else if (nodeTemplate()) {\n    <ng-container\n      [ngTemplateOutlet]=\"nodeTemplate()\"\n      [ngTemplateOutletContext]=\"{ node, isChecked, onChecked }\"\n    ></ng-container>\n  } @else {\n    <label tuiLabel class=\"tree-custom-class__label-checkbox-container\">\n      <input\n        size=\"s\"\n        tuiCheckbox\n        type=\"checkbox\"\n        [ngModel]=\"isChecked\"\n        (ngModelChange)=\"onChecked(node, $event)\"\n      />\n      <small>{{ node.name }}</small>\n    </label>\n  }\n</ng-template>\n"]}

package/esm2022/lib/components/inputs/param-tree/services/param-tree.service.mjs

@@ -0,0 +1,116 @@
+import { DestroyRef, inject, Injectable, signal } from '@angular/core';
+import { BehaviorSubject, catchError, combineLatest, debounceTime, EMPTY, expand, filter, from, iif, map, mergeMap, of, Subject, switchMap, take, tap, } from 'rxjs';
+import { TUI_TREE_LOADING, TUI_TREE_START } from '@taiga-ui/kit';
+import { startWith } from 'rxjs/operators';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TREE_LOADER } from '../tokens/param-tree.tokens';
+import { just } from '../../../../utils';
+import { DEBOUNCE_TIME_FOR_SYNC_NEXT_VALUES } from '../consts/param-tree.consts';
+import * as i0 from "@angular/core";
+export class ParamTreeService {
+    constructor() {
+        this._loading = inject(TUI_TREE_LOADING);
+        this._start$ = inject(TUI_TREE_START, { optional: true });
+        this._loader = inject(TREE_LOADER);
+        this._destroyRef = inject(DestroyRef);
+        this._loaderNode$ = new Subject();
+        this._defaultNodeOpenedState$ = new BehaviorSubject(undefined);
+        this._lastCheckedNode$ = new BehaviorSubject(null);
+        this._load$ = new Subject();
+        this._parentChildrenMap = new Map([
+            [this._loading, []],
+        ]);
+        this._nodes$ = new BehaviorSubject([]);
+        this._loadedChildren$ = new Subject();
+        this.defaultNodeOpenedState$ = this._defaultNodeOpenedState$.asObservable();
+        this.lastCheckedNode$ = this._lastCheckedNode$.asObservable();
+        this.loaderNode$ = this._loaderNode$.asObservable();
+        this.openedNodesState = signal(new Map());
+        this.checkedNodesState = signal(new Map());
+        this._firstLevelNodes = this._start$ ? [this._start$] : [];
+        this._firstLevelNodesLoaded = false;
+        this.nodes$ = this._nodes$.asObservable();
+        this._load$
+            .pipe(mergeMap((load) => this._load(load.node, !load.config?.initial).pipe(map((firstLevelNodes) => ({ load, firstLevelNodes })))), tap(({ load: { config }, firstLevelNodes }) => {
+            if (config?.initial) {
+                this._firstLevelNodes = firstLevelNodes ?? [];
+            }
+        }), mergeMap(({ load }) => iif(() => !!load.config?.opened, this._recursiveLoad(load.node), just())), map(() => this._firstLevelNodes), startWith([this._loading]), takeUntilDestroyed(this._destroyRef))
+            .subscribe((nodes) => {
+            this._nodes$.next(nodes);
+        });
+        combineLatest([this.loaderNode$, this.defaultNodeOpenedState$])
+            .pipe(debounceTime(DEBOUNCE_TIME_FOR_SYNC_NEXT_VALUES), takeUntilDestroyed(this._destroyRef))
+            .subscribe(([loader, opened]) => {
+            this.loadFirstLevelNodes(loader, opened);
+        });
+    }
+    _recursiveLoad(startedNode) {
+        return of(startedNode).pipe(expand((node) => {
+            if (this.hasChildren(node)) {
+                return this._load(node).pipe(switchMap((children) => from(children)), catchError(() => EMPTY));
+            }
+            if (node.children) {
+                return from(node.children);
+            }
+            return EMPTY;
+        }));
+    }
+    loadFirstLevelNodes(node, opened = true) {
+        if (!this._firstLevelNodesLoaded) {
+            this._load$.next({ node, config: { initial: true, opened } });
+            this._firstLevelNodesLoaded = true;
+        }
+    }
+    _load(node, setChildren = true) {
+        return this._loader.loadChildren(node).pipe(tap((children) => {
+            if (setChildren) {
+                for (const child of children) {
+                    child.parent = node;
+                }
+                node.children = children;
+                this._parentChildrenMap.set(node, children);
+                this._loadedChildren$.next(children);
+            }
+            const childfree = [node, ...children].filter((item) => !this.hasChildren(item));
+            for (const item of childfree) {
+                this._parentChildrenMap.set(item, []);
+            }
+        }));
+    }
+    loadChildren(node) {
+        const result = this._loadedChildren$.asObservable().pipe(filter(([firstChild]) => firstChild?.parent === node), take(1));
+        const children = this.getChildren(node);
+        if (children && children[0] !== this._loading) {
+            return of(children);
+        }
+        this._parentChildrenMap.set(node, [this._loading]);
+        this._load$.next({ node });
+        return result;
+    }
+    getChildren(node) {
+        return this._parentChildrenMap.get(node) || [this._loading];
+    }
+    hasChildren(node) {
+        return this._loader.hasChildren(node);
+    }
+    getTopLevelNodes() {
+        return this._firstLevelNodes;
+    }
+    setLoaderNode(loaderNode, defaultNodeOpenedState) {
+        this._loaderNode$.next(loaderNode);
+        this._defaultNodeOpenedState$.next(defaultNodeOpenedState);
+    }
+    setLastCheckedNode(node) {
+        this._lastCheckedNode$.next(node);
+    }
+    equals(node1, node2) {
+        return this._loader.equals(node1, node2);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTreeService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTreeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-tree.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-register-base/src/lib/components/inputs/param-tree/services/param-tree.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EACL,eAAe,EACf,UAAU,EACV,aAAa,EACb,YAAY,EACZ,KAAK,EACL,MAAM,EACN,MAAM,EACN,IAAI,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EAER,EAAE,EACF,OAAO,EACP,SAAS,EACT,IAAI,EACJ,GAAG,GACJ,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,kCAAkC,EAAE,MAAM,6BAA6B,CAAC;;AAGjF,MAAM,OAAO,gBAAgB;IA4B3B;QA3BiB,aAAQ,GAAG,MAAM,CAAe,gBAAgB,CAAC,CAAC;QAClD,YAAO,GAAG,MAAM,CAAe,cAAc,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACnE,YAAO,GAAG,MAAM,CAA8B,WAAW,CAAC,CAAC;QAC3D,gBAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAEjC,iBAAY,GAAG,IAAI,OAAO,EAAgB,CAAC;QAC3C,6BAAwB,GAAG,IAAI,eAAe,CAAsB,SAAS,CAAC,CAAC;QAC/E,sBAAiB,GAAG,IAAI,eAAe,CAAsB,IAAI,CAAC,CAAC;QACnE,WAAM,GAAG,IAAI,OAAO,EAAkB,CAAC;QACvC,uBAAkB,GAAG,IAAI,GAAG,CAA+B;YAC1E,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;SACpB,CAAC,CAAC;QACc,YAAO,GAAG,IAAI,eAAe,CAAiB,EAAE,CAAC,CAAC;QAClD,qBAAgB,GAAG,IAAI,OAAO,EAAkB,CAAC;QAElD,4BAAuB,GAAG,IAAI,CAAC,wBAAwB,CAAC,YAAY,EAAE,CAAC;QACvE,qBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;QACzD,gBAAW,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;QAE/C,qBAAgB,GAAG,MAAM,CAAC,IAAI,GAAG,EAAyB,CAAC,CAAC;QAC5D,sBAAiB,GAAG,MAAM,CAAC,IAAI,GAAG,EAAgC,CAAC,CAAC;QAE5E,qBAAgB,GAAmB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACtE,2BAAsB,GAAG,KAAK,CAAC;QAEvB,WAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QAGnD,IAAI,CAAC,MAAM;aACR,IAAI,CACH,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAChB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAC/C,GAAG,CAAC,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,CACtD,CACF,EACD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE;YAC5C,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;gBACpB,IAAI,CAAC,gBAAgB,GAAG,eAAe,IAAI,EAAE,CAAC;YAChD,CAAC;QACH,CAAC,CAAC,EACF,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CACpB,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CACzE,EACD,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAChC,SAAS,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAC1B,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CACrC;aACA,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEL,aAAa,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,uBAAuB,CAAC,CAAC;aAC5D,IAAI,CAAC,YAAY,CAAC,kCAAkC,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC5F,SAAS,CAAC,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE;YAC9B,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,cAAc,CAAC,WAAyB;QAC9C,OAAO,EAAE,CAAC,WAAW,CAAC,CAAC,IAAI,CACzB,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACd,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAC1B,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EACvC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CACxB,CAAC;YACJ,CAAC;YAED,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAClB,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7B,CAAC;YAED,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,mBAAmB,CAAC,IAAkB,EAAE,SAAkB,IAAI;QACnE,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;YAC9D,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACrC,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,IAAkB,EAAE,WAAW,GAAG,IAAI;QAClD,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CACzC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YACf,IAAI,WAAW,EAAE,CAAC;gBAChB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;oBAC7B,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;gBACtB,CAAC;gBACD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;gBACzB,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;gBAC5C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvC,CAAC;YAED,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,GAAG,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;YAChF,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;gBAC7B,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACxC,CAAC;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,YAAY,CAAC,IAAkB;QACpC,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC,IAAI,CACtD,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC,EACrD,IAAI,CAAC,CAAC,CAAC,CACR,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAExC,IAAI,QAAQ,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9C,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;QACtB,CAAC;QAED,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QAE3B,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,WAAW,CAAC,IAAkB;QACnC,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAEM,WAAW,CAAC,IAAkB;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAEM,gBAAgB;QACrB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAEM,aAAa,CAAC,UAAwB,EAAE,sBAAgC;QAC7E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACnC,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;IAC7D,CAAC;IAEM,kBAAkB,CAAC,IAAyB;QACjD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAEM,MAAM,CAAC,KAAmB,EAAE,KAAmB;QACpD,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;+GAjJU,gBAAgB;mHAAhB,gBAAgB;;4FAAhB,gBAAgB;kBAD5B,UAAU","sourcesContent":["import { DestroyRef, inject, Injectable, signal } from '@angular/core';\nimport {\n  BehaviorSubject,\n  catchError,\n  combineLatest,\n  debounceTime,\n  EMPTY,\n  expand,\n  filter,\n  from,\n  iif,\n  map,\n  mergeMap,\n  Observable,\n  of,\n  Subject,\n  switchMap,\n  take,\n  tap,\n} from 'rxjs';\nimport { TUI_TREE_LOADING, TUI_TREE_START } from '@taiga-ui/kit';\nimport { startWith } from 'rxjs/operators';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ILoadConfig, ITreeNode, SmaTreeLoader } from '../types/param-tree.types';\nimport { TREE_LOADER } from '../tokens/param-tree.tokens';\nimport { just } from '../../../../utils';\nimport { DEBOUNCE_TIME_FOR_SYNC_NEXT_VALUES } from '../consts/param-tree.consts';\n\n@Injectable()\nexport class ParamTreeService<T> {\n  private readonly _loading = inject<ITreeNode<T>>(TUI_TREE_LOADING);\n  private readonly _start$ = inject<ITreeNode<T>>(TUI_TREE_START, { optional: true });\n  private readonly _loader = inject<SmaTreeLoader<ITreeNode<T>>>(TREE_LOADER);\n  private readonly _destroyRef = inject(DestroyRef);\n\n  private readonly _loaderNode$ = new Subject<ITreeNode<T>>();\n  private readonly _defaultNodeOpenedState$ = new BehaviorSubject<boolean | undefined>(undefined);\n  private readonly _lastCheckedNode$ = new BehaviorSubject<ITreeNode<T> | null>(null);\n  private readonly _load$ = new Subject<ILoadConfig<T>>();\n  private readonly _parentChildrenMap = new Map<ITreeNode<T>, ITreeNode<T>[]>([\n    [this._loading, []],\n  ]);\n  private readonly _nodes$ = new BehaviorSubject<ITreeNode<T>[]>([]);\n  private readonly _loadedChildren$ = new Subject<ITreeNode<T>[]>();\n\n  public readonly defaultNodeOpenedState$ = this._defaultNodeOpenedState$.asObservable();\n  public readonly lastCheckedNode$ = this._lastCheckedNode$.asObservable();\n  public readonly loaderNode$ = this._loaderNode$.asObservable();\n\n  public readonly openedNodesState = signal(new Map<ITreeNode<T>, boolean>());\n  public readonly checkedNodesState = signal(new Map<ITreeNode<T>, boolean | null>());\n\n  private _firstLevelNodes: ITreeNode<T>[] = this._start$ ? [this._start$] : [];\n  private _firstLevelNodesLoaded = false;\n\n  public readonly nodes$ = this._nodes$.asObservable();\n\n  constructor() {\n    this._load$\n      .pipe(\n        mergeMap((load) =>\n          this._load(load.node, !load.config?.initial).pipe(\n            map((firstLevelNodes) => ({ load, firstLevelNodes }))\n          )\n        ),\n        tap(({ load: { config }, firstLevelNodes }) => {\n          if (config?.initial) {\n            this._firstLevelNodes = firstLevelNodes ?? [];\n          }\n        }),\n        mergeMap(({ load }) =>\n          iif(() => !!load.config?.opened, this._recursiveLoad(load.node), just())\n        ),\n        map(() => this._firstLevelNodes),\n        startWith([this._loading]),\n        takeUntilDestroyed(this._destroyRef)\n      )\n      .subscribe((nodes) => {\n        this._nodes$.next(nodes);\n      });\n\n    combineLatest([this.loaderNode$, this.defaultNodeOpenedState$])\n      .pipe(debounceTime(DEBOUNCE_TIME_FOR_SYNC_NEXT_VALUES), takeUntilDestroyed(this._destroyRef))\n      .subscribe(([loader, opened]) => {\n        this.loadFirstLevelNodes(loader, opened);\n      });\n  }\n\n  private _recursiveLoad(startedNode: ITreeNode<T>) {\n    return of(startedNode).pipe(\n      expand((node) => {\n        if (this.hasChildren(node)) {\n          return this._load(node).pipe(\n            switchMap((children) => from(children)),\n            catchError(() => EMPTY)\n          );\n        }\n\n        if (node.children) {\n          return from(node.children);\n        }\n\n        return EMPTY;\n      })\n    );\n  }\n\n  public loadFirstLevelNodes(node: ITreeNode<T>, opened: boolean = true): void {\n    if (!this._firstLevelNodesLoaded) {\n      this._load$.next({ node, config: { initial: true, opened } });\n      this._firstLevelNodesLoaded = true;\n    }\n  }\n\n  private _load(node: ITreeNode<T>, setChildren = true): Observable<ITreeNode<T>[]> {\n    return this._loader.loadChildren(node).pipe(\n      tap((children) => {\n        if (setChildren) {\n          for (const child of children) {\n            child.parent = node;\n          }\n          node.children = children;\n          this._parentChildrenMap.set(node, children);\n          this._loadedChildren$.next(children);\n        }\n\n        const childfree = [node, ...children].filter((item) => !this.hasChildren(item));\n        for (const item of childfree) {\n          this._parentChildrenMap.set(item, []);\n        }\n      })\n    );\n  }\n\n  public loadChildren(node: ITreeNode<T>): Observable<ITreeNode<T>[]> {\n    const result = this._loadedChildren$.asObservable().pipe(\n      filter(([firstChild]) => firstChild?.parent === node),\n      take(1)\n    );\n    const children = this.getChildren(node);\n\n    if (children && children[0] !== this._loading) {\n      return of(children);\n    }\n\n    this._parentChildrenMap.set(node, [this._loading]);\n    this._load$.next({ node });\n\n    return result;\n  }\n\n  public getChildren(node: ITreeNode<T>): ITreeNode<T>[] {\n    return this._parentChildrenMap.get(node) || [this._loading];\n  }\n\n  public hasChildren(node: ITreeNode<T>): boolean {\n    return this._loader.hasChildren(node);\n  }\n\n  public getTopLevelNodes(): ITreeNode<T>[] {\n    return this._firstLevelNodes;\n  }\n\n  public setLoaderNode(loaderNode: ITreeNode<T>, defaultNodeOpenedState?: boolean): void {\n    this._loaderNode$.next(loaderNode);\n    this._defaultNodeOpenedState$.next(defaultNodeOpenedState);\n  }\n\n  public setLastCheckedNode(node: ITreeNode<T> | null): void {\n    this._lastCheckedNode$.next(node);\n  }\n\n  public equals(node1: ITreeNode<T>, node2: ITreeNode<T>): boolean {\n    return this._loader.equals(node1, node2);\n  }\n}\n"]}

package/esm2022/lib/components/inputs/param-tree/services/sync-tree-loader.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SyncTreeLoaderService {
+    loadChildren({ children }) {
+        return of(children ?? []);
+    }
+    hasChildren({ haveChildren }) {
+        return !!haveChildren;
+    }
+    equals(value1, value2) {
+        return value1 === value2;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SyncTreeLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SyncTreeLoaderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SyncTreeLoaderService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy10cmVlLWxvYWRlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlZ2lzdGVyLWJhc2Uvc3JjL2xpYi9jb21wb25lbnRzL2lucHV0cy9wYXJhbS10cmVlL3NlcnZpY2VzL3N5bmMtdHJlZS1sb2FkZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBSXRDLE1BQU0sT0FBTyxxQkFBcUI7SUFDekIsWUFBWSxDQUFDLEVBQUUsUUFBUSxFQUFnQjtRQUM1QyxPQUFPLEVBQUUsQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVNLFdBQVcsQ0FBQyxFQUFFLFlBQVksRUFBZ0I7UUFDL0MsT0FBTyxDQUFDLENBQUMsWUFBWSxDQUFDO0lBQ3hCLENBQUM7SUFFTSxNQUFNLENBQUMsTUFBb0IsRUFBRSxNQUFvQjtRQUN0RCxPQUFPLE1BQU0sS0FBSyxNQUFNLENBQUM7SUFDM0IsQ0FBQzsrR0FYVSxxQkFBcUI7bUhBQXJCLHFCQUFxQjs7NEZBQXJCLHFCQUFxQjtrQkFEakMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUsIG9mIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBJVHJlZU5vZGUsIFNtYVRyZWVMb2FkZXIgfSBmcm9tICcuLi90eXBlcy9wYXJhbS10cmVlLnR5cGVzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFN5bmNUcmVlTG9hZGVyU2VydmljZTxUPiBpbXBsZW1lbnRzIFNtYVRyZWVMb2FkZXI8SVRyZWVOb2RlPFQ+PiB7XG4gIHB1YmxpYyBsb2FkQ2hpbGRyZW4oeyBjaGlsZHJlbiB9OiBJVHJlZU5vZGU8VD4pOiBPYnNlcnZhYmxlPElUcmVlTm9kZTxUPltdPiB7XG4gICAgcmV0dXJuIG9mKGNoaWxkcmVuID8/IFtdKTtcbiAgfVxuXG4gIHB1YmxpYyBoYXNDaGlsZHJlbih7IGhhdmVDaGlsZHJlbiB9OiBJVHJlZU5vZGU8VD4pOiBib29sZWFuIHtcbiAgICByZXR1cm4gISFoYXZlQ2hpbGRyZW47XG4gIH1cblxuICBwdWJsaWMgZXF1YWxzKHZhbHVlMTogSVRyZWVOb2RlPFQ+LCB2YWx1ZTI6IElUcmVlTm9kZTxUPik6IGJvb2xlYW4ge1xuICAgIHJldHVybiB2YWx1ZTEgPT09IHZhbHVlMjtcbiAgfVxufVxuIl19

package/esm2022/lib/components/inputs/param-tree/tokens/param-tree.tokens.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const TREE_LOADER = new InjectionToken('SMA_TREE_LOADER');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW0tdHJlZS50b2tlbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmVnaXN0ZXItYmFzZS9zcmMvbGliL2NvbXBvbmVudHMvaW5wdXRzL3BhcmFtLXRyZWUvdG9rZW5zL3BhcmFtLXRyZWUudG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHL0MsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksY0FBYyxDQUF5QixpQkFBaUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNtYVRyZWVMb2FkZXIgfSBmcm9tICcuLi90eXBlcy9wYXJhbS10cmVlLnR5cGVzJztcblxuZXhwb3J0IGNvbnN0IFRSRUVfTE9BREVSID0gbmV3IEluamVjdGlvblRva2VuPFNtYVRyZWVMb2FkZXI8dW5rbm93bj4+KCdTTUFfVFJFRV9MT0FERVInKTtcbiJdfQ==

package/esm2022/lib/components/inputs/param-tree/types/param-tree.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW0tdHJlZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZWdpc3Rlci1iYXNlL3NyYy9saWIvY29tcG9uZW50cy9pbnB1dHMvcGFyYW0tdHJlZS90eXBlcy9wYXJhbS10cmVlLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUdWlIYW5kbGVyIH0gZnJvbSAnQHRhaWdhLXVpL2Nkayc7XG5pbXBvcnQgeyBUdWlUcmVlTG9hZGVyIH0gZnJvbSAnQHRhaWdhLXVpL2tpdCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU21hVHJlZUxvYWRlcjxUPiBleHRlbmRzIFR1aVRyZWVMb2FkZXI8VD4ge1xuICBlcXVhbHModmFsdWUxOiBULCB2YWx1ZTI6IFQpOiBib29sZWFuO1xufVxuXG4vKiog0JrQvtC90YTQuNCzINC00LvRjyDQv9C+0LTQs9GA0YPQt9C60Lgg0LTQvtGH0LXRgNC90LjRhSDRg9C30LvQvtCyICovXG5leHBvcnQgaW50ZXJmYWNlIElMb2FkQ29uZmlnPFQ+IHtcbiAgLyoqINCj0LfQtdC7INC00LvRjyDQutC+0YLQvtGA0L7Qs9C+INC/0YDQvtC40YHRhdC+0LTQuNGCINC30LDQs9GA0YPQt9C60LAgKi9cbiAgbm9kZTogSVRyZWVOb2RlPFQ+O1xuICAvKiog0JTQvtC/0L7Qu9C90LjRgtC10LvRjNC90LDRjyDQutC+0L3RhNC40LPRg9GA0LDRhtC40Y8g0LfQsNCz0YDRg9C30LrQuCAqL1xuICBjb25maWc/OiB7XG4gICAgLyoqINCv0LLQu9GP0LXRgtGB0Y8g0LvQuCDRgtC10LrRg9GJ0LDRjyDQt9Cw0LPRgNGD0LfQutCwINC90LDRh9Cw0LvRjNC90L7QuSAo0LTQu9GPINC40L3QuNGG0LjQsNC70LjQt9Cw0YbQuNC4INCy0LXRgNGF0L3QtdCz0L4g0YPRgNC+0LLQvdGPINGD0LfQu9C+0LIpICovXG4gICAgaW5pdGlhbD86IGJvb2xlYW47XG4gICAgLyoqXG4gICAgICog0KDQtdC20LjQvCDQt9Cw0LPRgNGD0LfQutC4INC00L7Rh9C10YDQvdC40YUg0YPQt9C70L7Qsi5cbiAgICAgKiDQldGB0LvQuCB0cnVlIC0g0LTQvtGH0LXRgNC90LjQtSDRg9C30LvRiyDQt9Cw0LPRgNGD0LbQsNGO0YLRgdGPINGA0LXQutGD0YDRgdC40LLQvdC+INC00L4g0L/QvtGB0LvQtdC00L3QtdCz0L4g0YPRgNC+0LLQvdGPXG4gICAgICogKi9cbiAgICBvcGVuZWQ/OiBib29sZWFuO1xuICB9O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElUcmVlTm9kZTxUID0gYW55PiB7XG4gIC8qKiDQndCw0LfQstCw0L3QuNC1INGD0LfQu9CwICovXG4gIG5hbWU6IHN0cmluZztcbiAgcGFyZW50PzogSVRyZWVOb2RlPFQ+O1xuICAvKiog0JXRgdGC0Ywg0LTQvtGH0LXRgNC90LjQtSDRg9C30LvRiyDQutC+0YLQvtGA0YvQtSDQvNC+0LbQvdC+INC30LDQs9GA0YPQt9C40YLRjCAqL1xuICBoYXZlQ2hpbGRyZW4/OiBib29sZWFuO1xuICAvKiog0JTQvtGH0LXRgNC90LjQtSDQt9Cw0LPRgNGD0LbQtdC90L3Ri9C1INGD0LfQu9GLICovXG4gIGNoaWxkcmVuPzogSVRyZWVOb2RlPFQ+W107XG4gIC8qKiDQlNC+0L/QvtC70L3QuNGC0LXQu9GM0L3Ri9C1INGB0LLQvtC50YHRgtCy0LAg0YPQt9C70LAgKi9cbiAgZGF0YT86IFQ7XG59XG5cbmV4cG9ydCB0eXBlIENoaWxkcmVuSGFuZGxlclR5cGU8Tm9kZVR5cGU+ID0gVHVpSGFuZGxlcjxcbiAgSVRyZWVOb2RlPE5vZGVUeXBlPixcbiAgcmVhZG9ubHkgSVRyZWVOb2RlPE5vZGVUeXBlPltdXG4+O1xuIl19

package/esm2022/lib/components/inputs/param-tree/utils/param-tree.utils.mjs

@@ -0,0 +1,9 @@
+export function transformItemToNode({ item, children, }) {
+    return {
+        name: item['name'],
+        haveChildren: !!children,
+        children: children || [],
+        data: item,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW0tdHJlZS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZWdpc3Rlci1iYXNlL3NyYy9saWIvY29tcG9uZW50cy9pbnB1dHMvcGFyYW0tdHJlZS91dGlscy9wYXJhbS10cmVlLnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE1BQU0sVUFBVSxtQkFBbUIsQ0FBZ0MsRUFDakUsSUFBSSxFQUNKLFFBQVEsR0FDQztJQUNULE9BQU87UUFDTCxJQUFJLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNsQixZQUFZLEVBQUUsQ0FBQyxDQUFDLFFBQVE7UUFDeEIsUUFBUSxFQUFFLFFBQVEsSUFBSSxFQUFFO1FBQ3hCLElBQUksRUFBRSxJQUFJO0tBQ1gsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJVHJlZU5vZGUgfSBmcm9tICcuLi90eXBlcy9wYXJhbS10cmVlLnR5cGVzJztcblxuaW50ZXJmYWNlIElBcmdzPFQ+IHtcbiAgaXRlbTogVDtcbiAgY2hpbGRyZW4/OiBJVHJlZU5vZGU8VD5bXTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHRyYW5zZm9ybUl0ZW1Ub05vZGU8VCBleHRlbmRzIFJlY29yZDxzdHJpbmcsIGFueT4+KHtcbiAgaXRlbSxcbiAgY2hpbGRyZW4sXG59OiBJQXJnczxUPik6IElUcmVlTm9kZTxUPiB7XG4gIHJldHVybiB7XG4gICAgbmFtZTogaXRlbVsnbmFtZSddLFxuICAgIGhhdmVDaGlsZHJlbjogISFjaGlsZHJlbixcbiAgICBjaGlsZHJlbjogY2hpbGRyZW4gfHwgW10sXG4gICAgZGF0YTogaXRlbSxcbiAgfTtcbn1cbiJdfQ==