@daffodil/design 0.60.0 → 0.62.0

package/esm2020/tree/tree/tree.component.mjs

@@ -0,0 +1,106 @@
+import { ChangeDetectionStrategy, Component, ContentChild, HostBinding, Input, TemplateRef, ViewEncapsulation, } from '@angular/core';
+import { flattenTree, } from '../utils/flatten-tree';
+import { hydrateTree } from '../utils/hydrate-tree';
+import { DaffTreeNotifierService } from './tree-notifier.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./tree-notifier.service";
+import * as i2 from "@angular/common";
+/**
+ * The `DaffTreeComponent` allows you to render tree structures as interactable ui.
+ *
+ * They can be used like:
+ *
+ * ```html
+ * <ul daff-tree [tree]="tree">
+ *   <ng-template #daffTreeItemWithChildrenTpl let-node>
+ *       <button daffTreeItem [node]="node">{{ node.title }} </button>
+ *   </ng-template>
+ *
+ *   <ng-template #daffTreeItemTpl let-node>
+ *       <a daffTreeItem [node]="node" [routerLink]="node.url">{{ node.title }}</a>
+ *   </ng-template>
+ * </ul>
+ * ```
+ *
+ * where `tree` is a {@link DaffTreeData}.
+ *
+ */
+export class DaffTreeComponent {
+    constructor(notifier) {
+        this.notifier = notifier;
+        /**
+         * The css class of the daff-tree.
+         *
+         * @docs-private
+         */
+        this.class = true;
+        /**
+         * The internal tree element.
+         */
+        this.tree = undefined;
+        /**
+         * The flattened tree data. You can iterate through this if you want to inspect
+         * the resulting array structure we computed to render the tree.
+         */
+        this.flatTree = [];
+        /**
+         * @docs-private
+         */
+        this._dataTree = undefined;
+    }
+    /**
+     * The tree data you would like to render.
+     */
+    get dataTree() {
+        return this._dataTree;
+    }
+    set dataTree(dataTree) {
+        if (!dataTree) {
+            this._dataTree = undefined;
+            this.tree = undefined;
+            this.flatTree = [];
+            return;
+        }
+        this._dataTree = dataTree;
+        this.tree = hydrateTree(this.dataTree);
+        this.flatTree = flattenTree(this.tree);
+    }
+    ;
+    /**
+     * The track-by function used to reduce tree-item re-renders
+     */
+    trackByTreeElement(index, el) {
+        return el.title;
+    }
+    /**
+     * @docs-private
+     */
+    ngOnInit() {
+        this.notifier.notice$.subscribe(() => {
+            this.flatTree = flattenTree(this.tree);
+        });
+    }
+}
+/** @nocollapse */ DaffTreeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeComponent, deps: [{ token: i1.DaffTreeNotifierService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ DaffTreeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: DaffTreeComponent, selector: "ul[daff-tree]", inputs: { dataTree: ["tree", "dataTree"] }, host: { properties: { "class.daff-tree": "this.class" } }, providers: [
+        DaffTreeNotifierService,
+    ], queries: [{ propertyName: "withChildrenTemplate", first: true, predicate: ["daffTreeItemWithChildrenTpl"], descendants: true, static: true }, { propertyName: "treeItemTemplate", first: true, predicate: ["daffTreeItemTpl"], descendants: true, static: true }], ngImport: i0, template: "<ng-container *ngFor=\"let node of flatTree; trackBy: trackByTreeElement\">\n\t<li [attr.aria-level]=\"node.level\">\n\t\t<ng-container \n\t\t\t*ngTemplateOutlet=\"node.hasChildren ? withChildrenTemplate : treeItemTemplate; context: { $implicit: node }\">\n\t\t</ng-container>\t\n\t</li>\n</ng-container>", styles: [".daff-tree{margin:0;padding:0;list-style:none;--tree-padding: 16px}.daff-tree-item{cursor:pointer;-webkit-user-select:none;user-select:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:block;position:relative;background:none;border:0;padding:8px 16px 8px 0;line-height:1.5rem;font-weight:400;text-align:left;text-decoration:none;width:100%;padding-left:calc(var(--tree-padding) * (var(--depth)))}.daff-tree-item:before{content:\"\";position:absolute;top:0;bottom:0;left:0;width:4px}.daff-tree-item:focus,.daff-tree-item:focus-visible{z-index:1}.daff-tree-item.selected{font-weight:600}.daff-tree-item__parent{position:relative}.daff-tree-item__parent:after{content:\"\";position:absolute;top:48%;right:16px;display:inline-block;border-right:2px solid currentColor;border-bottom:2px solid currentColor;width:8px;height:8px;transform:translateY(-50%) rotate(45deg);transition:transform .15s}.daff-tree-item__parent.open:after{top:56%;transform:translateY(-50%) rotate(225deg)}\n"], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ul[daff-tree]', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        DaffTreeNotifierService,
+                    ], template: "<ng-container *ngFor=\"let node of flatTree; trackBy: trackByTreeElement\">\n\t<li [attr.aria-level]=\"node.level\">\n\t\t<ng-container \n\t\t\t*ngTemplateOutlet=\"node.hasChildren ? withChildrenTemplate : treeItemTemplate; context: { $implicit: node }\">\n\t\t</ng-container>\t\n\t</li>\n</ng-container>", styles: [".daff-tree{margin:0;padding:0;list-style:none;--tree-padding: 16px}.daff-tree-item{cursor:pointer;-webkit-user-select:none;user-select:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:block;position:relative;background:none;border:0;padding:8px 16px 8px 0;line-height:1.5rem;font-weight:400;text-align:left;text-decoration:none;width:100%;padding-left:calc(var(--tree-padding) * (var(--depth)))}.daff-tree-item:before{content:\"\";position:absolute;top:0;bottom:0;left:0;width:4px}.daff-tree-item:focus,.daff-tree-item:focus-visible{z-index:1}.daff-tree-item.selected{font-weight:600}.daff-tree-item__parent{position:relative}.daff-tree-item__parent:after{content:\"\";position:absolute;top:48%;right:16px;display:inline-block;border-right:2px solid currentColor;border-bottom:2px solid currentColor;width:8px;height:8px;transform:translateY(-50%) rotate(45deg);transition:transform .15s}.daff-tree-item__parent.open:after{top:56%;transform:translateY(-50%) rotate(225deg)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DaffTreeNotifierService }]; }, propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class.daff-tree']
+            }], dataTree: [{
+                type: Input,
+                args: ['tree']
+            }], withChildrenTemplate: [{
+                type: ContentChild,
+                args: ['daffTreeItemWithChildrenTpl', { static: true }]
+            }], treeItemTemplate: [{
+                type: ContentChild,
+                args: ['daffTreeItemTpl', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/tree-item/tree-item.directive.mjs

@@ -0,0 +1,154 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, HostBinding, HostListener, Inject, Input, } from '@angular/core';
+import { DaffTreeNotifierService } from '../tree/tree-notifier.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../tree/tree-notifier.service";
+/**
+ * The `DaffTreeItemDirective` allows you to demarcate the elements which are
+ * tree-children that interact with the parent tree.
+ *
+ * They can be used like:
+ *
+ * ```html
+ * <ul daff-tree [tree]="tree">
+ *   <ng-template #daffTreeItemWithChildrenTpl let-node>
+ *       <button daffTreeItem [node]="node">{{ node.title }} </button>
+ *   </ng-template>
+ *
+ *   <ng-template #daffTreeItemTpl let-node>
+ *       <a daffTreeItem [node]="node" [routerLink]="node.url">{{ node.title }}</a>
+ *   </ng-template>
+ * </ul>
+ * ```
+ *
+ * where `tree` is a {@link DaffTreeData} and `daff-tree` is a {@link DaffTreeComponent}.
+ *
+ */
+export class DaffTreeItemDirective {
+    constructor(document, treeNotifier) {
+        this.document = document;
+        this.treeNotifier = treeNotifier;
+        /**
+         * The css class of the daff-tree.
+         *
+         * @docs-private
+         */
+        this.class = true;
+        /**
+         * The css class of a DaffTreeItemDirective that has children.
+         *
+         * @docs-private
+         */
+        this.classParent = false;
+        /**
+         * The CSS class indicating whether or not the tree is `open`.
+         */
+        this.openClass = false;
+        /**
+         * Whether or not the tree item is the currently active item.
+         * Note that there is no requirement there there only be one active item at a time.
+         */
+        this.selected = false;
+    }
+    /**
+     * The CSS class indicating whether or not the tree is `selected`.
+     */
+    get selectedClass() {
+        return this.selected;
+    }
+    ;
+    /**
+     * The {@link DaffTreeFlatNode} associated with this specific tree item.
+     */
+    get node() {
+        return this._node;
+    }
+    ;
+    set node(val) {
+        this._node = val;
+        this.id = 'tree-' + this._node.id;
+        this.ariaExpanded = this._node._treeRef.open ? 'true' : 'false';
+        this.depth = this._node.level;
+        this.classParent = this._node.hasChildren;
+        this.openClass = this._node._treeRef.open;
+    }
+    /**
+     * @docs-private
+     */
+    onEscape() {
+        this.toggleParent(this.node);
+    }
+    /**
+     * @docs-private
+     */
+    onClick() {
+        if (this.node.hasChildren) {
+            this.toggleTree(this.node);
+        }
+        this.treeNotifier.notify();
+    }
+    /**
+     * Toggle the open state of the tree's parent.
+     */
+    toggleParent(node) {
+        if (node._treeRef?.parent.parent === undefined) {
+            return;
+        }
+        node._treeRef.parent.open = !node._treeRef.parent.open;
+        this.document.getElementById('tree-' + node._treeRef.parent.id).focus();
+    }
+    /**
+     * Toggle the open state of this specific subtree tree.
+     */
+    toggleTree(node) {
+        if (node._treeRef.open === false) {
+            node._treeRef.open = true;
+        }
+        else {
+            node._treeRef.open = false;
+        }
+    }
+}
+/** @nocollapse */ DaffTreeItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeItemDirective, deps: [{ token: DOCUMENT }, { token: i1.DaffTreeNotifierService }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ DaffTreeItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: DaffTreeItemDirective, selector: "[daffTreeItem]", inputs: { node: "node", selected: "selected" }, host: { listeners: { "keydown.escape": "onEscape()", "click": "onClick()" }, properties: { "class.daff-tree-item": "this.class", "class.daff-tree-item__parent": "this.classParent", "attr.id": "this.id", "attr.aria-expanded": "this.ariaExpanded", "style.--depth": "this.depth", "class.selected": "this.selectedClass", "class.open": "this.openClass" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[daffTreeItem]',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.DaffTreeNotifierService }]; }, propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class.daff-tree-item']
+            }], classParent: [{
+                type: HostBinding,
+                args: ['class.daff-tree-item__parent']
+            }], id: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }], ariaExpanded: [{
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], depth: [{
+                type: HostBinding,
+                args: ['style.--depth']
+            }], selectedClass: [{
+                type: HostBinding,
+                args: ['class.selected']
+            }], openClass: [{
+                type: HostBinding,
+                args: ['class.open']
+            }], node: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], onEscape: [{
+                type: HostListener,
+                args: ['keydown.escape']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-item.directive.js","sourceRoot":"","sources":["../../../../../libs/design/tree/src/tree-item/tree-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n  Directive,\n  HostBinding,\n  HostListener,\n  Inject,\n  Input,\n} from '@angular/core';\n\nimport { DaffTreeNotifierService } from '../tree/tree-notifier.service';\nimport { DaffTreeFlatNode } from '../utils/flatten-tree';\n\n/**\n * The `DaffTreeItemDirective` allows you to demarcate the elements which are\n * tree-children that interact with the parent tree.\n *\n * They can be used like:\n *\n * ```html\n * <ul daff-tree [tree]=\"tree\">\n *   <ng-template #daffTreeItemWithChildrenTpl let-node>\n *       <button daffTreeItem [node]=\"node\">{{ node.title }} </button>\n *   </ng-template>\n *\n *   <ng-template #daffTreeItemTpl let-node>\n *       <a daffTreeItem [node]=\"node\" [routerLink]=\"node.url\">{{ node.title }}</a>\n *   </ng-template>\n * </ul>\n * ```\n *\n * where `tree` is a {@link DaffTreeData} and `daff-tree` is a {@link DaffTreeComponent}.\n *\n */\n@Directive({\n  selector: '[daffTreeItem]',\n})\nexport class DaffTreeItemDirective {\n\n  /**\n   * The css class of the daff-tree.\n   *\n   * @docs-private\n   */\n  @HostBinding('class.daff-tree-item') class = true;\n\n  /**\n   * The css class of a DaffTreeItemDirective that has children.\n   *\n   * @docs-private\n   */\n  @HostBinding('class.daff-tree-item__parent') classParent = false;\n\n  /**\n   * The html `id` of the tree item. This is derived from the {@link DaffTreeData}.\n   *\n   * @docs-private\n   */\n  @HostBinding('attr.id') id;\n\n  /**\n   * Accessibility property, notifying users about whether\n   * or not the tree item is open.\n   *\n   * @docs-private\n   */\n  @HostBinding('attr.aria-expanded') ariaExpanded: string;\n\n  /**\n   * A css variable indicating the depth of the tree.\n   * You can use this to style your templates if you want to\n   * use different designs at different depths.\n   */\n  @HostBinding('style.--depth') depth: number;\n\n  /**\n   * The CSS class indicating whether or not the tree is `selected`.\n   */\n  @HostBinding('class.selected') get selectedClass() {\n    return this.selected;\n  };\n\n  /**\n   * The CSS class indicating whether or not the tree is `open`.\n   */\n  @HostBinding('class.open') openClass = false;\n\n  /**\n   * The {@link DaffTreeFlatNode} associated with this specific tree item.\n   *\n   * @docs-private\n   */\n  private _node: DaffTreeFlatNode;\n\n  /**\n   * The {@link DaffTreeFlatNode} associated with this specific tree item.\n   */\n  @Input()\n  get node() {\n    return this._node;\n  };\n  set node(val: DaffTreeFlatNode) {\n    this._node = val;\n    this.id = 'tree-' + this._node.id;\n    this.ariaExpanded = this._node._treeRef.open ? 'true' : 'false';\n    this.depth = this._node.level;\n    this.classParent = this._node.hasChildren;\n    this.openClass = this._node._treeRef.open;\n  }\n\n  /**\n   * Whether or not the tree item is the currently active item.\n   * Note that there is no requirement there there only be one active item at a time.\n   */\n  @Input() selected = false;\n\n  constructor(\n    @Inject(DOCUMENT) private document: any,\n    private treeNotifier: DaffTreeNotifierService,\n  ) {}\n\n  /**\n   * @docs-private\n   */\n  @HostListener('keydown.escape')\n  onEscape() {\n    this.toggleParent(this.node);\n  }\n\n  /**\n   * @docs-private\n   */\n  @HostListener('click')\n  onClick() {\n    if(this.node.hasChildren) {\n      this.toggleTree(this.node);\n    }\n    this.treeNotifier.notify();\n  }\n\n  /**\n   * Toggle the open state of the tree's parent.\n   */\n  toggleParent(node: DaffTreeFlatNode) {\n    if(node._treeRef?.parent.parent === undefined) {\n      return;\n    }\n    node._treeRef.parent.open = !node._treeRef.parent.open;\n    (<Document>this.document).getElementById('tree-' + node._treeRef.parent.id).focus();\n  }\n\n  /**\n   * Toggle the open state of this specific subtree tree.\n   */\n  toggleTree(node: DaffTreeFlatNode) {\n    if(node._treeRef.open === false) {\n      node._treeRef.open = true;\n    } else {\n      node._treeRef.open = false;\n    }\n  }\n}\n"]}

package/esm2020/tree/tree.module.mjs

@@ -0,0 +1,31 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { DaffTreeItemDirective } from './tree-item/tree-item.directive';
+import { DaffTreeComponent } from './tree/tree.component';
+import * as i0 from "@angular/core";
+export class DaffTreeModule {
+}
+/** @nocollapse */ DaffTreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ DaffTreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeModule, declarations: [DaffTreeComponent,
+        DaffTreeItemDirective], imports: [CommonModule], exports: [DaffTreeComponent,
+        DaffTreeItemDirective] });
+/** @nocollapse */ DaffTreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeModule, imports: [[
+            CommonModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffTreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        DaffTreeComponent,
+                        DaffTreeItemDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        DaffTreeComponent,
+                        DaffTreeItemDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2Rlc2lnbi90cmVlL3NyYy90cmVlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUN4RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFlMUQsTUFBTSxPQUFPLGNBQWM7OzhIQUFkLGNBQWM7K0hBQWQsY0FBYyxpQkFYdkIsaUJBQWlCO1FBQ2pCLHFCQUFxQixhQUdyQixZQUFZLGFBR1osaUJBQWlCO1FBQ2pCLHFCQUFxQjsrSEFHWixjQUFjLFlBUmhCO1lBQ1AsWUFBWTtTQUNiOzJGQU1VLGNBQWM7a0JBYjFCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFO3dCQUNaLGlCQUFpQjt3QkFDakIscUJBQXFCO3FCQUN0QjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsWUFBWTtxQkFDYjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsaUJBQWlCO3dCQUNqQixxQkFBcUI7cUJBQ3RCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IERhZmZUcmVlSXRlbURpcmVjdGl2ZSB9IGZyb20gJy4vdHJlZS1pdGVtL3RyZWUtaXRlbS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRGFmZlRyZWVDb21wb25lbnQgfSBmcm9tICcuL3RyZWUvdHJlZS5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBEYWZmVHJlZUNvbXBvbmVudCxcbiAgICBEYWZmVHJlZUl0ZW1EaXJlY3RpdmUsXG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBEYWZmVHJlZUNvbXBvbmVudCxcbiAgICBEYWZmVHJlZUl0ZW1EaXJlY3RpdmUsXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIERhZmZUcmVlTW9kdWxlIHsgfVxuIl19

package/esm2020/tree/utils/flatten-tree.mjs

@@ -0,0 +1,47 @@
+/**
+ * Flatten a DaffTreeUi<unknown> into an array, removing elements from the array
+ * below nodes in the tree that are not open.
+ */
+export const flattenTree = (daffUiTree) => {
+    const tree = [];
+    let items = [
+        {
+            ...daffUiTree,
+            title: 'Root',
+            level: 0,
+            url: '/',
+            data: undefined,
+            open: true,
+            _treeRef: daffUiTree,
+        },
+    ];
+    while (items) {
+        const el = items.pop();
+        if (!el) {
+            break;
+        }
+        if (el.open) {
+            items = [
+                ...items,
+                ...el.items.map((i) => ({
+                    ...i,
+                    level: el.level + 1,
+                    _treeRef: i,
+                })).reverse(),
+            ];
+        }
+        if (el._treeRef.parent?.open) {
+            tree.push({
+                id: el.id,
+                title: el.title,
+                level: el.level,
+                url: el.url,
+                hasChildren: el.items.length > 0,
+                data: undefined,
+                _treeRef: el._treeRef,
+            });
+        }
+    }
+    return tree;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/utils/hydrate-tree.mjs

@@ -0,0 +1,31 @@
+import { traverse } from './traverse-tree';
+export const daffDataTreeToUiTree = (data, parent, open = false) => ({
+    id: data.id ?? data.title,
+    title: data.title,
+    url: data.url,
+    data: data.data,
+    open,
+    parent,
+    items: [],
+});
+/**
+ * This function translates the original data given to us by the client
+ * to the internal representation of the tree used by the {@link DaffTreeComponent}
+ */
+export const hydrateTree = (data) => {
+    const tree = daffDataTreeToUiTree(data, undefined, true);
+    let treeStack = [
+        tree,
+    ];
+    traverse(data, (el) => {
+        const treeEl = treeStack.pop();
+        treeEl.items = el.items.map((i) => daffDataTreeToUiTree(i, treeEl, false));
+        treeStack = [
+            ...treeStack,
+            ...treeEl.items,
+        ];
+        return el;
+    }, 'items');
+    return tree;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/utils/transform-in-place.mjs

@@ -0,0 +1,23 @@
+import { traverse } from './traverse-tree';
+/**
+ * Transform a tree-like structure in-place into a {@link DaffTreeData}.
+ *
+ * This will mutate the original object, hydrating with additional properties.
+ *
+ * @param tree - The data structure representing tree-like data.
+ * @param transformFn - A user-supplied function that will transform the user
+ *  type into a {@link DaffTreeData}
+ * @param key - The property of the your tree that indicates which
+ *  key contains the "children" of your tree structure.
+ *
+ */
+export const daffTransformTreeInPlace = (tree, transformFn, key) => traverse(tree, (el) => {
+    const r = Object.assign(el, transformFn(el));
+    r.items = el[key];
+    el = r;
+    return el;
+}, 
+// This type is confusing. I don't understand why it has to be here,
+// the associated error message is incomprehensible.
+key);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/utils/traverse-tree.mjs

@@ -0,0 +1,21 @@
+/**
+ * Traverse the tree, pre-order, right-to-left
+ */
+export const traverse = (tree, visit, key) => {
+    let stack = [
+        tree,
+    ];
+    while (stack) {
+        const el = stack.pop();
+        if (!el) {
+            break;
+        }
+        visit(el);
+        stack = [
+            ...stack,
+            ...el[key],
+        ];
+    }
+    return tree;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhdmVyc2UtdHJlZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvZGVzaWduL3RyZWUvc3JjL3V0aWxzL3RyYXZlcnNlLXRyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsQ0FDdEIsSUFBTyxFQUNQLEtBQXFCLEVBQ3JCLEdBQThCLEVBQzNCLEVBQUU7SUFDTCxJQUFJLEtBQUssR0FBRztRQUNWLElBQUk7S0FDTCxDQUFDO0lBRUYsT0FBTSxLQUFLLEVBQUU7UUFDWCxNQUFNLEVBQUUsR0FBRyxLQUFLLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsSUFBRyxDQUFDLEVBQUUsRUFBRTtZQUNOLE1BQU07U0FDUDtRQUVELEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUVWLEtBQUssR0FBRztZQUNOLEdBQUcsS0FBSztZQUNSLEdBQWlCLEVBQUUsQ0FBQyxHQUFHLENBQUM7U0FDekIsQ0FBQztLQUNIO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWN1cnNpdmVUcmVlS2V5T2ZUeXBlIH0gZnJvbSAnLi4vaW50ZXJmYWNlcy9yZWN1cnNpdmUta2V5JztcblxuLyoqXG4gKiBUcmF2ZXJzZSB0aGUgdHJlZSwgcHJlLW9yZGVyLCByaWdodC10by1sZWZ0XG4gKi9cbmV4cG9ydCBjb25zdCB0cmF2ZXJzZSA9IDxUIGV4dGVuZHMgUmVjb3JkPGFueSwgYW55PiwgViBleHRlbmRzIFJlY29yZDxhbnksIGFueT4gPSBUPihcbiAgdHJlZTogVCxcbiAgdmlzaXQ6ICh0cmVlOiBUKSA9PiBWLFxuICBrZXk6IFJlY3Vyc2l2ZVRyZWVLZXlPZlR5cGU8VD4sXG4pOiBWID0+IHtcbiAgbGV0IHN0YWNrID0gW1xuICAgIHRyZWUsXG4gIF07XG5cbiAgd2hpbGUoc3RhY2spIHtcbiAgICBjb25zdCBlbCA9IHN0YWNrLnBvcCgpO1xuICAgIGlmKCFlbCkge1xuICAgICAgYnJlYWs7XG4gICAgfVxuXG4gICAgdmlzaXQoZWwpO1xuXG4gICAgc3RhY2sgPSBbXG4gICAgICAuLi5zdGFjayxcbiAgICAgIC4uLjxUW10+PHVua25vd24+ZWxba2V5XSxcbiAgICBdO1xuICB9XG5cbiAgcmV0dXJuIHRyZWU7XG59O1xuIl19