ngx-ode-ui 4.6.0-dev-produit.2 → 4.6.0-dev-integration.2

package/esm5/lib/components/ellipsis/ellipsis.component.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/ellipsis/ellipsis.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, Input, Injector } from '@angular/core';
+/**
+ * A simple ellipsis component that switches text-overflow on click.
+ * Add an ellipsis={'hide'| 'expand'} attirubute on your element.
+ * Default behavior is 'hide', so that it's the same than the raw CSS
+ */
+var EllipsisComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(EllipsisComponent, _super);
+    function EllipsisComponent(eltRef, injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.eltRef = eltRef;
+        _this._ellipsis = 'hide';
+        _this.isExpanded = false;
+        _this.initialStyle = Object.assign({}, _this.eltRef.nativeElement.style);
+        return _this;
+    }
+    Object.defineProperty(EllipsisComponent.prototype, "ellipsis", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            if (!!value) {
+                this._ellipsis = value;
+                if (this._ellipsis == 'expand') {
+                    this.eltRef.nativeElement.className = 'expand';
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    EllipsisComponent.prototype.onClick = /**
+     * @return {?}
+     */
+    function () {
+        if (this._ellipsis == 'hide') {
+            return;
+        }
+        if (!this.isExpanded) {
+            this.isExpanded = true;
+            Object.assign(this.eltRef.nativeElement.style, {
+                textOverflow: 'clip',
+                overflow: 'auto',
+                whiteSpace: 'normal',
+            });
+        }
+        else {
+            this.isExpanded = false;
+            this.eltRef.nativeElement.style = this.initialStyle;
+        }
+    };
+    EllipsisComponent.decorators = [
+        { type: Component, args: [{
+                    selector: '[ellipsis]',
+                    template: "<ng-content></ng-content>",
+                    host: {
+                        '(click)': 'onClick()',
+                    },
+                    styles: [":host{display:block;width:8em;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}:host.expand{cursor:pointer}"]
+                }] }
+    ];
+    /** @nocollapse */
+    EllipsisComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: Injector }
+    ]; };
+    EllipsisComponent.propDecorators = {
+        ellipsis: [{ type: Input }]
+    };
+    return EllipsisComponent;
+}(OdeComponent));
+export { EllipsisComponent };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype._ellipsis;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.isExpanded;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.initialStyle;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.eltRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/form-errors/form-errors.component.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/form-errors/form-errors.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Input, Injector } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { LabelsService } from '../../services/labels.service';
+var FormErrorsComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(FormErrorsComponent, _super);
+    function FormErrorsComponent(labelsService, injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.labelsService = labelsService;
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    FormErrorsComponent.prototype.getErrorsArray = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var errorsArray = [];
+        for (var prop in this.ref.errors) {
+            errorsArray.push({ name: prop, value: this.ref.errors[prop] });
+        }
+        return errorsArray;
+    };
+    /**
+     * @param {?} label
+     * @return {?}
+     */
+    FormErrorsComponent.prototype.labels = /**
+     * @param {?} label
+     * @return {?}
+     */
+    function (label) {
+        return this.labelsService.getLabel(label);
+    };
+    FormErrorsComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-form-errors',
+                    template: "<div *ngIf=\"ref && ref.errors && (ref.dirty || ref.touched)\" class=\"form-errors\">\n  <div *ngFor=\"let error of getErrorsArray()\">\n    <span>{{ 'form.error.' + error.name | translate: error.value }}</span>\n    <span *ngIf=\"error.name == 'pattern'\">{{expectedPatternMsg}}</span>\n  </div>\n</div>\n",
+                    styles: [".form-errors{font-size:.8em;color:#dc143c;font-style:italic}"]
+                }] }
+    ];
+    /** @nocollapse */
+    FormErrorsComponent.ctorParameters = function () { return [
+        { type: LabelsService },
+        { type: Injector }
+    ]; };
+    FormErrorsComponent.propDecorators = {
+        ref: [{ type: Input, args: ['control',] }],
+        expectedPatternMsg: [{ type: Input, args: ['expectedPatternMsg',] }]
+    };
+    return FormErrorsComponent;
+}(OdeComponent));
+export { FormErrorsComponent };
+if (false) {
+    /** @type {?} */
+    FormErrorsComponent.prototype.ref;
+    /** @type {?} */
+    FormErrorsComponent.prototype.expectedPatternMsg;
+    /**
+     * @type {?}
+     * @private
+     */
+    FormErrorsComponent.prototype.labelsService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/form-field/form-field.component.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/form-field/form-field.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, Input, Injector } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+var FormFieldComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(FormFieldComponent, _super);
+    function FormFieldComponent(injector) {
+        return _super.call(this, injector) || this;
+    }
+    FormFieldComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-form-field',
+                    template: "<div class=\"form-field\">\n  <label>\n    {{ label | translate }}\n    <span *ngIf=\"required\" class=\"asterisque\">*</span>\n    <ode-message-sticker *ngIf=\"help\"\n                     [type]=\"'info'\"\n                     [messages]=\"[help]\">\n    </ode-message-sticker>\n  </label>\n  <ng-content></ng-content>\n</div>\n",
+                    styles: ["div.form-field{display:flex;align-items:center}div.form-field>>>>*{flex:1;margin-left:5px}div.form-field>:first-child{flex:0 0 200px;margin-left:0}div.form-field message-sticker{font-size:1.3em}div.form-field .asterisque{color:#dc143c}"]
+                }] }
+    ];
+    /** @nocollapse */
+    FormFieldComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    FormFieldComponent.propDecorators = {
+        label: [{ type: Input }],
+        help: [{ type: Input }],
+        required: [{ type: Input }]
+    };
+    return FormFieldComponent;
+}(OdeComponent));
+export { FormFieldComponent };
+if (false) {
+    /** @type {?} */
+    FormFieldComponent.prototype.label;
+    /** @type {?} */
+    FormFieldComponent.prototype.help;
+    /** @type {?} */
+    FormFieldComponent.prototype.required;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1maWVsZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL2NvbXBvbmVudHMvZm9ybS1maWVsZC9mb3JtLWZpZWxkLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0QsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUU1QztJQUt3Qyw4Q0FBWTtJQUtsRCw0QkFBWSxRQUFrQjtlQUM1QixrQkFBTSxRQUFRLENBQUM7SUFDakIsQ0FBQzs7Z0JBWkYsU0FBUyxTQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLHVWQUEwQzs7aUJBRTNDOzs7O2dCQVAwQixRQUFROzs7d0JBU2hDLEtBQUs7dUJBQ0wsS0FBSzsyQkFDTCxLQUFLOztJQUtSLHlCQUFDO0NBQUEsQUFiRCxDQUt3QyxZQUFZLEdBUW5EO1NBUlksa0JBQWtCOzs7SUFDN0IsbUNBQXVCOztJQUN2QixrQ0FBc0I7O0lBQ3RCLHNDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPZGVDb21wb25lbnQgfSBmcm9tICduZ3gtb2RlLWNvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdvZGUtZm9ybS1maWVsZCcsXG4gIHRlbXBsYXRlVXJsOiAnLi9mb3JtLWZpZWxkLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vZm9ybS1maWVsZC5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIEZvcm1GaWVsZENvbXBvbmVudCBleHRlbmRzIE9kZUNvbXBvbmVudCB7XG4gIEBJbnB1dCgpIGxhYmVsOiBzdHJpbmc7XG4gIEBJbnB1dCgpIGhlbHA6IHN0cmluZztcbiAgQElucHV0KCkgcmVxdWlyZWQ6IGJvb2xlYW47XG5cbiAgY29uc3RydWN0b3IoaW5qZWN0b3I6IEluamVjdG9yKSB7XG4gICAgc3VwZXIoaW5qZWN0b3IpO1xuICB9XG59XG4iXX0=

package/esm5/lib/components/item-tree/item-tree.component.js

@@ -0,0 +1,345 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/item-tree/item-tree.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, Output, ViewChild, TemplateRef, Injector } from '@angular/core';
+/**
+ * @template T
+ */
+var ItemTreeComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(ItemTreeComponent, _super);
+    function ItemTreeComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        /**
+         * * Inputs ***
+         */
+        // Items
+        _this.items = [];
+        // Property containing the list of child objects.
+        _this.childrenProperty = 'children';
+        // Property to display in the list
+        _this.displayProperty = 'label';
+        // Filter pipe argument
+        _this.filter = '';
+        // OrderBy pipe argument
+        _this.order = [];
+        // Reverse the order pipe
+        _this.reverse = false;
+        _this._flattenProps = [];
+        // Disable the opener icon
+        _this.disableOpener = false;
+        // Use checkboxes instead of selecting items
+        _this.checkboxMode = false;
+        /**
+         * * Outputs ***
+         */
+        _this.onSelect = new EventEmitter();
+        _this.onCheck = new EventEmitter();
+        _this._depth = 0;
+        _this.unfolded = [];
+        return _this;
+    }
+    Object.defineProperty(ItemTreeComponent.prototype, "flatten", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._flattenProps;
+        },
+        // Flatten the tree on the specified properties
+        set: 
+        // Flatten the tree on the specified properties
+        /**
+         * @param {?} flattenProps
+         * @return {?}
+         */
+        function (flattenProps) {
+            if (!this.isFlattened() && flattenProps.length > 0) {
+                this._selectedItem = this._lastSelectedItem;
+            }
+            else if (this.isFlattened && flattenProps.length < 1) {
+                this.flagIfParent();
+            }
+            this._flattenProps = flattenProps;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        _super.prototype.ngOnInit.call(this);
+        this.flagIfParent();
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.selectItem = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        this._selectedItem = item;
+        if (this.childItemTree) {
+            delete this.childItemTree._selectedItem;
+        }
+        /** @type {?} */
+        var idx = this.unfolded.indexOf(item);
+        if (!this.disableOpener && idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+        this.bubbleSelect(item);
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.checkItem = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        this.onCheck.emit(item);
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.bubbleSelect = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        this._lastSelectedItem = item;
+        this.onSelect.emit(item);
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.isSelected = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;
+    };
+    /**
+     * @param {?} event
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.toggleFold = /**
+     * @param {?} event
+     * @param {?} item
+     * @return {?}
+     */
+    function (event, item) {
+        event.stopPropagation();
+        /** @type {?} */
+        var idx = this.unfolded.indexOf(item);
+        if (idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.isFolded = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.display = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return this.displayProperty && item[this.displayProperty];
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.getChildren = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return item[this.childrenProperty] || [];
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.hasChildren = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return this.getChildren(item).length > 0;
+    };
+    /**
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.isFlattened = /**
+     * @return {?}
+     */
+    function () {
+        return this._flattenProps.length;
+    };
+    /**
+     * @private
+     * @return {?}
+     */
+    ItemTreeComponent.prototype.flagIfParent = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        if (!this._lastSelectedItem) {
+            return;
+        }
+        /** @type {?} */
+        var findSubItem = (/**
+         * @param {?} item
+         * @param {?} target
+         * @return {?}
+         */
+        function (item, target) {
+            if (item === target) {
+                return true;
+            }
+            if (_this.hasChildren(item)) {
+                return _this.getChildren(item).find((/**
+                 * @param {?} subItem
+                 * @return {?}
+                 */
+                function (subItem) {
+                    return findSubItem(subItem, target);
+                }));
+            }
+            return false;
+        });
+        for (var i in this.items) {
+            /** @type {?} */
+            var item = this.items[i];
+            if (item === this._lastSelectedItem ||
+                findSubItem(item, this._lastSelectedItem)) {
+                this._selectedItem = item;
+                this.unfolded = [item];
+                break;
+            }
+        }
+        this.changeDetector.markForCheck();
+    };
+    ItemTreeComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-item-tree',
+                    template: "<ul [ngClass]=\"{ flattened: isFlattened() }\">\n  <li *ngFor=\"let item of (items | flattenObjArray: flatten | filter: filter | orderBy: order:reverse)\"\n      [ngClass]=\"{ selected: isSelected(item), unfolded: !isFolded(item), parent: hasChildren(item), root: _depth === 0 }\">\n    <a href=\"javascript:void(0)\" (click)=\"selectItem(item)\" *ngIf=\"!checkboxMode\">\n      <i class=\"opener\" (click)=\"toggleFold($event, item)\"\n         *ngIf=\"!isFlattened() && hasChildren(item) && !disableOpener\"></i>\n      <span *ngIf=\"displayProperty\">{{ display(item) }}</span>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </a>\n    <div class=\"checkbox__item\" *ngIf=\"checkboxMode\">\n      <input id=\"all\" type=\"checkbox\" [(ngModel)]=\"item.check\" ngDefaultControl>\n      <label *ngIf=\"displayProperty\" for=\"all\" (click)=\"checkItem(item)\">{{display(item)}}</label>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </div>\n    <ode-item-tree\n      [items]=\"getChildren(item)\"\n      [children]=\"childrenProperty\"\n      [display]=\"displayProperty\"\n      [displayTemplate]=\"displayTemplate\"\n      [filter]=\"filter\"\n      [order]=\"order\"\n      [reverse]=\"reverse\"\n      [lastSelected]=\"_lastSelectedItem\"\n      [depth]=\"_depth + 1\"\n      [disableOpener]=\"disableOpener\"\n      [checkboxMode]=\"checkboxMode\"\n      (onSelect)=\"bubbleSelect($event)\"\n      (onCheck)=\"checkItem($event)\"\n      *ngIf=\"(checkboxMode && hasChildren(item)) || (!isFlattened() && hasChildren(item) && !isFolded(item))\">\n    </ode-item-tree>\n  </li>\n</ul>\n"
+                }] }
+    ];
+    /** @nocollapse */
+    ItemTreeComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    ItemTreeComponent.propDecorators = {
+        items: [{ type: Input }],
+        childrenProperty: [{ type: Input, args: ['children',] }],
+        displayProperty: [{ type: Input, args: ['display',] }],
+        displayTemplate: [{ type: Input }],
+        filter: [{ type: Input }],
+        order: [{ type: Input }],
+        reverse: [{ type: Input }],
+        flatten: [{ type: Input }],
+        disableOpener: [{ type: Input }],
+        checkboxMode: [{ type: Input }],
+        onSelect: [{ type: Output }],
+        onCheck: [{ type: Output }],
+        childItemTree: [{ type: ViewChild, args: [ItemTreeComponent, { static: false },] }],
+        _lastSelectedItem: [{ type: Input, args: ['lastSelected',] }],
+        _depth: [{ type: Input, args: ['depth',] }]
+    };
+    return ItemTreeComponent;
+}(OdeComponent));
+export { ItemTreeComponent };
+if (false) {
+    /**
+     * * Inputs ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.items;
+    /** @type {?} */
+    ItemTreeComponent.prototype.childrenProperty;
+    /** @type {?} */
+    ItemTreeComponent.prototype.displayProperty;
+    /** @type {?} */
+    ItemTreeComponent.prototype.displayTemplate;
+    /** @type {?} */
+    ItemTreeComponent.prototype.filter;
+    /** @type {?} */
+    ItemTreeComponent.prototype.order;
+    /** @type {?} */
+    ItemTreeComponent.prototype.reverse;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype._flattenProps;
+    /** @type {?} */
+    ItemTreeComponent.prototype.disableOpener;
+    /** @type {?} */
+    ItemTreeComponent.prototype.checkboxMode;
+    /**
+     * * Outputs ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.onSelect;
+    /** @type {?} */
+    ItemTreeComponent.prototype.onCheck;
+    /**
+     * * View ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.childItemTree;
+    /**
+     * * Internal Logic ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype._lastSelectedItem;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype._selectedItem;
+    /** @type {?} */
+    ItemTreeComponent.prototype._depth;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype.unfolded;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-tree.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/item-tree/item-tree.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, EventEmitter, Input, OnInit, Output, ViewChild, ContentChild, TemplateRef, Injector } from '@angular/core';\n\n@Component({\n    selector: 'ode-item-tree',\n    templateUrl: './item-tree.component.html'\n})\nexport class ItemTreeComponent<T> extends OdeComponent implements OnInit {\n\n    constructor(injector: Injector) {\n        super(injector);\n    }\n\n    /**** Inputs ****/\n\n    // Items\n    @Input() items: Array<any> = [];\n\n    // Property containing the list of child objects.\n    @Input('children') childrenProperty = 'children';\n    // Property to display in the list\n    @Input('display') displayProperty = 'label';\n    @Input() displayTemplate: TemplateRef<any>;\n    // Filter pipe argument\n    @Input() filter: (Object | string | Function) = '';\n    // OrderBy pipe argument\n    @Input() order: (Array<any> | string | Function) = [];\n    // Reverse the order pipe\n    @Input() reverse: any = false;\n    // Flatten the tree on the specified properties\n    @Input()\n    set flatten(flattenProps: Array<string>) {\n        if (!this.isFlattened() && flattenProps.length > 0) {\n            this._selectedItem = this._lastSelectedItem;\n        } else if (this.isFlattened && flattenProps.length < 1) {\n            this.flagIfParent();\n        }\n        this._flattenProps = flattenProps;\n    }\n    get flatten(): Array<string> {\n        return this._flattenProps;\n    }\n    private _flattenProps: Array<string> = [];\n\n    // Disable the opener icon\n    @Input() disableOpener = false;\n\n    // Use checkboxes instead of selecting items\n    @Input() checkboxMode = false;\n\n    /**** Outputs ****/\n\n    @Output() onSelect: EventEmitter<T> = new EventEmitter<T>();\n\n    @Output() onCheck: EventEmitter<T> = new EventEmitter<T>();\n\n    /**** View ****/\n\n    @ViewChild(ItemTreeComponent, { static: false }) childItemTree: ItemTreeComponent<T>;\n\n    /**** Internal Logic ****/\n\n    @Input('lastSelected') _lastSelectedItem: T;\n    private _selectedItem: T;\n    @Input('depth') _depth = 0;\n    private unfolded: T[] = [];\n\n    ngOnInit() {\n        super.ngOnInit();\n        this.flagIfParent();\n    }\n\n    public selectItem(item: T) {\n        this._selectedItem = item;\n        if (this.childItemTree) {\n            delete this.childItemTree._selectedItem;\n        }\n        const idx = this.unfolded.indexOf(item);\n        if (!this.disableOpener && idx < 0) {\n            this.unfolded.push(item);\n        } else {\n          this.unfolded.splice(idx, 1);\n        }\n        this.bubbleSelect(item);\n    }\n\n    public checkItem(item: T) {\n        this.onCheck.emit(item);\n    }\n\n    public bubbleSelect(item: T) {\n        this._lastSelectedItem = item;\n        this.onSelect.emit(item);\n    }\n\n    public isSelected(item) {\n        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;\n    }\n\n    public toggleFold(event: Event, item: T) {\n        event.stopPropagation();\n        const idx = this.unfolded.indexOf(item);\n        if (idx < 0) {\n            this.unfolded.push(item);\n        } else {\n            this.unfolded.splice(idx, 1);\n        }\n    }\n\n    public isFolded(item: T) {\n        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;\n    }\n\n    public display(item: T) {\n        return this.displayProperty && item[this.displayProperty];\n    }\n\n    public getChildren(item) {\n        return item[this.childrenProperty] || [];\n    }\n\n    public hasChildren(item) {\n        return this.getChildren(item).length > 0;\n    }\n\n    isFlattened() {\n        return this._flattenProps.length;\n    }\n\n    private flagIfParent() {\n        if (!this._lastSelectedItem) {\n            return;\n        }\n\n        const findSubItem = (item, target) => {\n            if (item === target) {\n                return true;\n            }\n            if (this.hasChildren(item)) {\n                return this.getChildren(item).find(subItem => {\n                    return findSubItem(subItem, target);\n                });\n            }\n            return false;\n        };\n\n        for (const i in this.items) {\n            const item = this.items[i];\n\n            if (item === this._lastSelectedItem ||\n                    findSubItem(item, this._lastSelectedItem)) {\n                this._selectedItem = item;\n                this.unfolded = [item];\n                break;\n            }\n        }\n\n        this.changeDetector.markForCheck();\n    }\n\n}\n"]}