@ni/nimble-angular 1.0.0-beta.13 → 1.0.0-beta.130

package/fesm2015/ni-nimble-angular.js

@@ -0,0 +1,781 @@
+import { Directive, Renderer2, ElementRef, Input, NgModule, forwardRef, EventEmitter, Output, HostListener, Optional, Host } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import '@ni/nimble-components/dist/esm/button';
+import { CheckboxControlValueAccessor, NG_VALUE_ACCESSOR, SelectControlValueAccessor, NgSelectOption, NumberValueAccessor, DefaultValueAccessor } from '@angular/forms';
+import '@ni/nimble-components/dist/esm/checkbox';
+import '@ni/nimble-components/dist/esm/drawer';
+import { DrawerState } from '@ni/nimble-components/dist/esm/drawer/types';
+export { DrawerLocation, DrawerState } from '@ni/nimble-components/dist/esm/drawer/types';
+import '@ni/nimble-components/dist/esm/listbox-option';
+import '@ni/nimble-components/dist/esm/menu';
+import '@ni/nimble-components/dist/esm/menu-item';
+import '@ni/nimble-components/dist/esm/number-field';
+import '@ni/nimble-components/dist/esm/select';
+import '@ni/nimble-components/dist/esm/tab';
+import '@ni/nimble-components/dist/esm/tab-panel';
+import '@ni/nimble-components/dist/esm/tabs';
+import '@ni/nimble-components/dist/esm/tabs-toolbar';
+import '@ni/nimble-components/dist/esm/text-field';
+export { NimbleTheme } from '@ni/nimble-components/dist/esm/theme-provider/themes';
+import '@ni/nimble-components/dist/esm/theme-provider';
+import '@ni/nimble-components/dist/esm/tree-item';
+import '@ni/nimble-components/dist/esm/tree-view';
+export { SelectionMode } from '@ni/nimble-components/dist/esm/tree-view/types';
+
+/**
+ * Conversion helpers for values coming from Angular templates via
+ * strings specified in templates or via property bindings
+ */
+/**
+ * Converts values from templates (empty string or null) or boolean bindings to a boolean property representation
+ */
+const toBooleanProperty = (value) => {
+    if (value === false || value === null) {
+        return false;
+    }
+    // For boolean attributes the empty string value is true
+    return true;
+};
+/**
+ * Converts values from templates (empty string or null) or boolean bindings to an Aria boolean
+ * attribute representation (the strings "true" or "false")
+ */
+const toBooleanAriaAttribute = (value) => {
+    if (value === false || value === null) {
+        return 'false';
+    }
+    // For boolean attributes the empty string value is true
+    return 'true';
+};
+/**
+ * Converts values from templates (number representation as a string) or number bindings to a number property representation
+ */
+const toNumberProperty = (value) => {
+    return Number(value);
+};
+
+/**
+ * Directive to provide Angular integration for the button.
+ */
+class NimbleButtonDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get appearance() {
+        return this.elementRef.nativeElement.appearance;
+    }
+    set appearance(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'appearance', value);
+    }
+    get disabled() {
+        return this.elementRef.nativeElement.disabled;
+    }
+    set disabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', toBooleanProperty(value));
+    }
+}
+NimbleButtonDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-button'
+            },] }
+];
+NimbleButtonDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleButtonDirective.propDecorators = {
+    appearance: [{ type: Input }],
+    disabled: [{ type: Input }]
+};
+
+class NimbleButtonModule {
+}
+NimbleButtonModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleButtonDirective],
+                imports: [CommonModule],
+                exports: [NimbleButtonDirective]
+            },] }
+];
+
+/**
+ * Extension of Angular's CheckboxControlValueAccessor to target the Nimble checkbox control.
+ *
+ * Directive decorator based on CheckboxControlValueAccessor decorator
+ * https://github.com/angular/angular/blob/master/packages/forms/src/directives/checkbox_value_accessor.ts#L42
+ */
+class NimbleCheckboxControlValueAccessorDirective extends CheckboxControlValueAccessor {
+}
+NimbleCheckboxControlValueAccessorDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-checkbox[formControlName],nimble-checkbox[formControl],nimble-checkbox[ngModel]',
+                // The following host metadata is duplicated from CheckboxControlValueAccessor
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: { '(change)': 'onChange($event.target.checked)', '(blur)': 'onTouched()' },
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => NimbleCheckboxControlValueAccessorDirective),
+                        multi: true
+                    }]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the checkbox.
+ */
+class NimbleCheckboxDirective {
+}
+NimbleCheckboxDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-checkbox'
+            },] }
+];
+
+class NimbleCheckboxModule {
+}
+NimbleCheckboxModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleCheckboxDirective, NimbleCheckboxControlValueAccessorDirective],
+                imports: [CommonModule],
+                exports: [NimbleCheckboxDirective, NimbleCheckboxControlValueAccessorDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the drawer.
+ */
+class NimbleDrawerDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.stateChange = new EventEmitter();
+    }
+    get location() {
+        return this.elementRef.nativeElement.location;
+    }
+    set location(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'location', value);
+    }
+    get state() {
+        return this.elementRef.nativeElement.state;
+    }
+    set state(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'state', value);
+    }
+    get modal() {
+        return this.elementRef.nativeElement.modal;
+    }
+    set modal(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'modal', toBooleanProperty(value));
+    }
+    show() {
+        this.state = DrawerState.Opening;
+    }
+    hide() {
+        this.state = DrawerState.Closing;
+    }
+    onStateChanged($event) {
+        if ($event.target === this.elementRef.nativeElement) {
+            this.stateChange.emit(this.state);
+        }
+    }
+}
+NimbleDrawerDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-drawer'
+            },] }
+];
+NimbleDrawerDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleDrawerDirective.propDecorators = {
+    location: [{ type: Input }],
+    state: [{ type: Input }],
+    modal: [{ type: Input }],
+    stateChange: [{ type: Output }],
+    onStateChanged: [{ type: HostListener, args: ['state-change', ['$event'],] }]
+};
+
+class NimbleDrawerModule {
+}
+NimbleDrawerModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleDrawerDirective],
+                imports: [CommonModule],
+                exports: [NimbleDrawerDirective]
+            },] }
+];
+
+/**
+ * Extension of Angular's SelectControlValueAccessor to target the Nimble select control.
+ *
+ * @see NimbleSelectOptionDirective
+ *
+ * Directive decorator based on SelectControlValueAccessor decorator
+ * https://github.com/angular/angular/blob/master/packages/forms/src/directives/select_control_value_accessor.ts#L85
+ */
+class NimbleSelectControlValueAccessorDirective extends SelectControlValueAccessor {
+}
+NimbleSelectControlValueAccessorDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-select:not([multiple])[formControlName],nimble-select:not([multiple])[formControl],nimble-select:not([multiple])[ngModel]',
+                // The following host metadata is duplicated from SelectControlValueAccessor
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: { '(change)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => NimbleSelectControlValueAccessorDirective),
+                        multi: true
+                    }]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the listbox option.
+ */
+class NimbleListboxOptionDirective extends NgSelectOption {
+    constructor(elementRef, renderer, select) {
+        super(elementRef, renderer, select);
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+    }
+    get disabled() {
+        return this.elementRef.nativeElement.disabled;
+    }
+    set disabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', toBooleanProperty(value));
+    }
+}
+NimbleListboxOptionDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-listbox-option'
+            },] }
+];
+NimbleListboxOptionDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: NimbleSelectControlValueAccessorDirective, decorators: [{ type: Optional }, { type: Host }] }
+];
+NimbleListboxOptionDirective.propDecorators = {
+    disabled: [{ type: Input }]
+};
+
+class NimbleListboxOptionModule {
+}
+NimbleListboxOptionModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleListboxOptionDirective],
+                imports: [CommonModule],
+                exports: [NimbleListboxOptionDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the menu.
+ */
+class NimbleMenuDirective {
+}
+NimbleMenuDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-menu'
+            },] }
+];
+
+class NimbleMenuModule {
+}
+NimbleMenuModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleMenuDirective],
+                imports: [CommonModule],
+                exports: [NimbleMenuDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the menu.
+ */
+class NimbleMenuItemDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get disabled() {
+        return this.elementRef.nativeElement.disabled;
+    }
+    set disabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', toBooleanProperty(value));
+    }
+}
+NimbleMenuItemDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-menu-item'
+            },] }
+];
+NimbleMenuItemDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleMenuItemDirective.propDecorators = {
+    disabled: [{ type: Input }]
+};
+
+class NimbleMenuItemModule {
+}
+NimbleMenuItemModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleMenuItemDirective],
+                imports: [CommonModule],
+                exports: [NimbleMenuItemDirective]
+            },] }
+];
+
+/**
+ * Extension of Angular's NumberValueAccessor to target the number-based inputs.
+ *
+ * Directive decorator based on NumberValueAccessor decorator
+ * https://github.com/angular/angular/blob/master/packages/forms/src/directives/number_value_accessor.ts#L43
+ */
+class NimbleNumberFieldControlValueAccessorDirective extends NumberValueAccessor {
+}
+NimbleNumberFieldControlValueAccessorDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-number-field[formControlName],nimble-number-field[formControl],nimble-number-field[ngModel]',
+                // The following host metadata is duplicated from NumberValueAccessor
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: { '(input)': 'onChange($event.target.value)', '(blur)': 'onTouched()' },
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => NimbleNumberFieldControlValueAccessorDirective),
+                        multi: true
+                    }]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the number field.
+ */
+class NimbleNumberFieldDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get readOnly() {
+        return this.elementRef.nativeElement.readOnly;
+    }
+    set readOnly(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'readOnly', toBooleanProperty(value));
+    }
+    get min() {
+        return this.elementRef.nativeElement.min;
+    }
+    set min(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'min', toNumberProperty(value));
+    }
+    get max() {
+        return this.elementRef.nativeElement.max;
+    }
+    set max(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'max', toNumberProperty(value));
+    }
+    get step() {
+        return this.elementRef.nativeElement.step;
+    }
+    set step(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'step', toNumberProperty(value));
+    }
+    get placeholder() {
+        return this.elementRef.nativeElement.placeholder;
+    }
+    set placeholder(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'placeholder', value);
+    }
+}
+NimbleNumberFieldDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-number-field'
+            },] }
+];
+NimbleNumberFieldDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleNumberFieldDirective.propDecorators = {
+    readOnly: [{ type: Input }],
+    min: [{ type: Input }],
+    max: [{ type: Input }],
+    step: [{ type: Input }],
+    placeholder: [{ type: Input }]
+};
+
+class NimbleNumberFieldModule {
+}
+NimbleNumberFieldModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleNumberFieldDirective, NimbleNumberFieldControlValueAccessorDirective],
+                imports: [CommonModule],
+                exports: [NimbleNumberFieldDirective, NimbleNumberFieldControlValueAccessorDirective]
+            },] }
+];
+
+/**
+ * Directive for Nimble select control Angular integration
+ */
+class NimbleSelectDirective {
+}
+NimbleSelectDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-select',
+            },] }
+];
+
+class NimbleSelectModule {
+}
+NimbleSelectModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleSelectDirective, NimbleSelectControlValueAccessorDirective],
+                imports: [CommonModule],
+                exports: [NimbleSelectDirective, NimbleSelectControlValueAccessorDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tab element.
+ */
+class NimbleTabDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get disabled() {
+        return this.elementRef.nativeElement.disabled;
+    }
+    set disabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', toBooleanProperty(value));
+    }
+}
+NimbleTabDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tab'
+            },] }
+];
+NimbleTabDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleTabDirective.propDecorators = {
+    disabled: [{ type: Input }]
+};
+
+class NimbleTabModule {
+}
+NimbleTabModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTabDirective],
+                imports: [CommonModule],
+                exports: [NimbleTabDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tab panel.
+ */
+class NimbleTabPanelDirective {
+}
+NimbleTabPanelDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tab-panel'
+            },] }
+];
+
+class NimbleTabPanelModule {
+}
+NimbleTabPanelModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTabPanelDirective],
+                imports: [CommonModule],
+                exports: [NimbleTabPanelDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tabs element.
+ */
+class NimbleTabsDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.activeidChange = new EventEmitter();
+    }
+    get activeid() {
+        return this.elementRef.nativeElement.activeid;
+    }
+    set activeid(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'activeid', value);
+    }
+    onChange($event) {
+        if ($event.target === this.elementRef.nativeElement) {
+            this.activeidChange.emit(this.activeid);
+        }
+    }
+}
+NimbleTabsDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tabs'
+            },] }
+];
+NimbleTabsDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleTabsDirective.propDecorators = {
+    activeid: [{ type: Input }],
+    activeidChange: [{ type: Output }],
+    onChange: [{ type: HostListener, args: ['change', ['$event'],] }]
+};
+
+class NimbleTabsModule {
+}
+NimbleTabsModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTabsDirective],
+                imports: [CommonModule],
+                exports: [NimbleTabsDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tabs toolbar.
+ */
+class NimbleTabsToolbarDirective {
+}
+NimbleTabsToolbarDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tabs-toolbar'
+            },] }
+];
+
+class NimbleTabsToolbarModule {
+}
+NimbleTabsToolbarModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTabsToolbarDirective],
+                imports: [CommonModule],
+                exports: [NimbleTabsToolbarDirective]
+            },] }
+];
+
+/**
+ * Extension of Angular's DefaultValueAccessor to target the text-based inputs.
+ *
+ * Directive decorator based on DefaultValueAccessor decorator
+ * https://github.com/angular/angular/blob/master/packages/forms/src/directives/default_value_accessor.ts#L72
+ */
+class NimbleTextFieldControlValueAccessorDirective extends DefaultValueAccessor {
+}
+NimbleTextFieldControlValueAccessorDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-text-field[formControlName],nimble-text-field[formControl],nimble-text-field[ngModel]',
+                // The following host metadata is duplicated from DefaultValueAccessor
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: {
+                    '(input)': '$any(this)._handleInput($event.target.value)',
+                    '(blur)': 'onTouched()',
+                    '(compositionstart)': '$any(this)._compositionStart()',
+                    '(compositionend)': '$any(this)._compositionEnd($event.target.value)'
+                },
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => NimbleTextFieldControlValueAccessorDirective),
+                        multi: true
+                    }]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the text field
+ */
+class NimbleTextFieldDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get readOnly() {
+        return this.elementRef.nativeElement.readOnly;
+    }
+    set readOnly(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'readOnly', toBooleanProperty(value));
+    }
+}
+NimbleTextFieldDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-text-field'
+            },] }
+];
+NimbleTextFieldDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleTextFieldDirective.propDecorators = {
+    readOnly: [{ type: Input }]
+};
+
+class NimbleTextFieldModule {
+}
+NimbleTextFieldModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTextFieldDirective, NimbleTextFieldControlValueAccessorDirective],
+                imports: [CommonModule],
+                exports: [NimbleTextFieldDirective, NimbleTextFieldControlValueAccessorDirective]
+            },] }
+];
+
+/**
+ * Directive for Angular integration for the theme provider
+ */
+class NimbleThemeProviderDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get theme() {
+        return this.elementRef.nativeElement.theme;
+    }
+    set theme(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'theme', value);
+    }
+}
+NimbleThemeProviderDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-theme-provider'
+            },] }
+];
+NimbleThemeProviderDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleThemeProviderDirective.propDecorators = {
+    theme: [{ type: Input }]
+};
+
+class NimbleThemeProviderModule {
+}
+NimbleThemeProviderModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleThemeProviderDirective],
+                imports: [CommonModule],
+                exports: [NimbleThemeProviderDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tree item.
+ */
+class NimbleTreeItemDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.expandedChange = new EventEmitter();
+    }
+    get disabled() {
+        return this.elementRef.nativeElement.disabled;
+    }
+    set disabled(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', toBooleanProperty(value));
+    }
+    get expanded() {
+        return this.elementRef.nativeElement.expanded;
+    }
+    set expanded(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'expanded', toBooleanProperty(value));
+    }
+    get selected() {
+        return this.elementRef.nativeElement.selected;
+    }
+    set selected(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'selected', toBooleanProperty(value));
+        // Needed because fast-foundation TreeView sets initial selection with an aria-selected query
+        this.renderer.setAttribute(this.elementRef.nativeElement, 'selected', toBooleanAriaAttribute(value));
+    }
+    onExpandedChange($event) {
+        if ($event.target === this.elementRef.nativeElement) {
+            this.expandedChange.emit(this.expanded);
+        }
+    }
+}
+NimbleTreeItemDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tree-item'
+            },] }
+];
+NimbleTreeItemDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleTreeItemDirective.propDecorators = {
+    disabled: [{ type: Input }],
+    expanded: [{ type: Input }],
+    selected: [{ type: Input }],
+    expandedChange: [{ type: Output }],
+    onExpandedChange: [{ type: HostListener, args: ['expanded-change', ['$event'],] }]
+};
+
+class NimbleTreeItemModule {
+}
+NimbleTreeItemModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTreeItemDirective],
+                imports: [CommonModule],
+                exports: [NimbleTreeItemDirective]
+            },] }
+];
+
+/**
+ * Directive to provide Angular integration for the tree view.
+ */
+class NimbleTreeViewDirective {
+    constructor(renderer, elementRef) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+    }
+    get selectionMode() {
+        return this.elementRef.nativeElement.selectionMode;
+    }
+    set selectionMode(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'selectionMode', value);
+    }
+}
+NimbleTreeViewDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'nimble-tree-view'
+            },] }
+];
+NimbleTreeViewDirective.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+NimbleTreeViewDirective.propDecorators = {
+    selectionMode: [{ type: Input }]
+};
+
+class NimbleTreeViewModule {
+}
+NimbleTreeViewModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [NimbleTreeViewDirective],
+                imports: [CommonModule],
+                exports: [NimbleTreeViewDirective]
+            },] }
+];
+
+/*
+ * Public API Surface of nimble-angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NimbleButtonDirective, NimbleButtonModule, NimbleCheckboxControlValueAccessorDirective, NimbleCheckboxDirective, NimbleCheckboxModule, NimbleDrawerDirective, NimbleDrawerModule, NimbleListboxOptionDirective, NimbleListboxOptionModule, NimbleMenuDirective, NimbleMenuItemDirective, NimbleMenuItemModule, NimbleMenuModule, NimbleNumberFieldControlValueAccessorDirective, NimbleNumberFieldDirective, NimbleNumberFieldModule, NimbleSelectControlValueAccessorDirective, NimbleSelectDirective, NimbleSelectModule, NimbleTabDirective, NimbleTabModule, NimbleTabPanelDirective, NimbleTabPanelModule, NimbleTabsDirective, NimbleTabsModule, NimbleTabsToolbarDirective, NimbleTabsToolbarModule, NimbleTextFieldControlValueAccessorDirective, NimbleTextFieldDirective, NimbleTextFieldModule, NimbleThemeProviderDirective, NimbleThemeProviderModule, NimbleTreeItemDirective, NimbleTreeItemModule, NimbleTreeViewDirective, NimbleTreeViewModule };
+//# sourceMappingURL=ni-nimble-angular.js.map