@clr/angular 12.0.5 → 13.0.0-next.0

package/esm2020/forms/combobox/combobox.module.mjs

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { ClrIconModule } from '../../icon/icon.module';
+import { ClrCommonFormsModule } from '../common/common.module';
+import { ClrConditionalModule } from '../../utils/conditional/conditional.module';
+import { ClrOption } from './option';
+import { ClrOptions } from './options';
+import { ClrCombobox } from './combobox';
+import { ClrComboboxContainer } from './combobox-container';
+import { ClrOptionSelected } from './option-selected.directive';
+import { ClrPopoverModuleNext } from '../../utils/popover/popover.module';
+import { ClrOptionItems } from './option-items.directive';
+import { ClrSpinnerModule } from '../../progress/spinner/spinner.module';
+import { ClrKeyFocusModule } from '../../utils/focus/key-focus/key-focus.module';
+import { angleIcon, checkCircleIcon, ClarityIcons, exclamationCircleIcon, windowCloseIcon } from '@cds/core/icon';
+import * as i0 from "@angular/core";
+export class ClrComboboxModule {
+    constructor() {
+        ClarityIcons.addIcons(exclamationCircleIcon, checkCircleIcon, angleIcon, windowCloseIcon);
+    }
+}
+ClrComboboxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrComboboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrComboboxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrComboboxModule, declarations: [ClrCombobox, ClrComboboxContainer, ClrOptions, ClrOption, ClrOptionSelected, ClrOptionItems], imports: [CommonModule,
+        FormsModule,
+        ClrIconModule,
+        ClrKeyFocusModule,
+        ClrCommonFormsModule,
+        ClrConditionalModule,
+        ClrPopoverModuleNext,
+        ClrSpinnerModule], exports: [ClrCommonFormsModule,
+        ClrCombobox,
+        ClrComboboxContainer,
+        ClrOptions,
+        ClrOption,
+        ClrOptionSelected,
+        ClrConditionalModule,
+        ClrOptionItems] });
+ClrComboboxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrComboboxModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ClrIconModule,
+            ClrKeyFocusModule,
+            ClrCommonFormsModule,
+            ClrConditionalModule,
+            ClrPopoverModuleNext,
+            ClrSpinnerModule,
+        ], ClrCommonFormsModule,
+        ClrConditionalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrComboboxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ClrIconModule,
+                        ClrKeyFocusModule,
+                        ClrCommonFormsModule,
+                        ClrConditionalModule,
+                        ClrPopoverModuleNext,
+                        ClrSpinnerModule,
+                    ],
+                    declarations: [ClrCombobox, ClrComboboxContainer, ClrOptions, ClrOption, ClrOptionSelected, ClrOptionItems],
+                    exports: [
+                        ClrCommonFormsModule,
+                        ClrCombobox,
+                        ClrComboboxContainer,
+                        ClrOptions,
+                        ClrOption,
+                        ClrOptionSelected,
+                        ClrConditionalModule,
+                        ClrOptionItems,
+                    ],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/forms/combobox/option-items.directive.mjs

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { NgForOf } from '@angular/common';
+import { Directive, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/option-selection.service";
+import * as i2 from "../../utils/popover/providers/popover-position.service";
+export class ClrOptionItems {
+    constructor(template, differs, optionService, positionService, vcr) {
+        this.template = template;
+        this.differs = differs;
+        this.optionService = optionService;
+        this.positionService = positionService;
+        this.vcr = vcr;
+        this.subscriptions = [];
+        this.filter = '';
+        this.differ = null;
+        this.iterableProxy = new NgForOf(this.vcr, this.template, this.differs);
+        this.subscriptions.push(optionService.inputChanged.subscribe(filter => {
+            this.filter = filter;
+            this.updateItems();
+        }));
+    }
+    set rawItems(items) {
+        this._rawItems = items ? items : [];
+        this.updateItems();
+    }
+    set trackBy(value) {
+        this.iterableProxy.ngForTrackBy = value;
+    }
+    set field(field) {
+        this._filterField = field;
+        this.optionService.displayField = field;
+    }
+    updateItems() {
+        if (!this._rawItems || this.filter === undefined || this.filter === null) {
+            return;
+        }
+        if (this._filterField) {
+            this.filteredItems = this._rawItems.filter(item => {
+                const objValue = item[this._filterField];
+                return objValue ? objValue.toString().toLowerCase().indexOf(this.filter.toLowerCase().toString()) > -1 : false;
+            });
+        }
+        else {
+            // Filter by all item object values
+            this.filteredItems = this._rawItems.filter(item => {
+                if (typeof item !== 'object') {
+                    return item.toString().toLowerCase().indexOf(this.filter.toString().toLowerCase()) > -1;
+                }
+                const objValues = Object.values(item).filter(value => {
+                    return value !== null && value !== undefined
+                        ? value.toString().toLowerCase().indexOf(this.filter.toString().toLowerCase()) > -1
+                        : false;
+                });
+                return objValues.length > 0;
+            });
+        }
+        this.iterableProxy.ngForOf = this.filteredItems;
+    }
+    ngDoCheck() {
+        if (!this.differ) {
+            this.differ = this.differs.find(this.filteredItems).create(this.iterableProxy.ngForTrackBy);
+        }
+        if (this.differ) {
+            const changes = this.differ.diff(this.filteredItems);
+            if (changes) {
+                this.iterableProxy.ngDoCheck();
+                this.positionService.realign();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrOptionItems.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptionItems, deps: [{ token: i0.TemplateRef }, { token: i0.IterableDiffers }, { token: i1.OptionSelectionService }, { token: i2.ClrPopoverPositionService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClrOptionItems.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrOptionItems, selector: "[clrOptionItems][clrOptionItemsOf]", inputs: { rawItems: ["clrOptionItemsOf", "rawItems"], trackBy: ["clrOptionItemsTrackBy", "trackBy"], field: ["clrOptionItemsField", "field"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptionItems, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrOptionItems][clrOptionItemsOf]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.IterableDiffers }, { type: i1.OptionSelectionService }, { type: i2.ClrPopoverPositionService }, { type: i0.ViewContainerRef }]; }, propDecorators: { rawItems: [{
+                type: Input,
+                args: ['clrOptionItemsOf']
+            }], trackBy: [{
+                type: Input,
+                args: ['clrOptionItemsTrackBy']
+            }], field: [{
+                type: Input,
+                args: ['clrOptionItemsField']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option-items.directive.js","sourceRoot":"","sources":["../../../../../projects/angular/src/forms/combobox/option-items.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport { NgForOf, NgForOfContext } from '@angular/common';\nimport {\n  Directive,\n  DoCheck,\n  Input,\n  IterableDiffer,\n  IterableDiffers,\n  TemplateRef,\n  TrackByFunction,\n  ViewContainerRef,\n  OnDestroy,\n} from '@angular/core';\n\nimport { OptionSelectionService } from './providers/option-selection.service';\nimport { Subscription } from 'rxjs';\nimport { ClrPopoverPositionService } from '../../utils/popover/providers/popover-position.service';\n\n@Directive({\n  selector: '[clrOptionItems][clrOptionItemsOf]',\n})\nexport class ClrOptionItems<T> implements DoCheck, OnDestroy {\n  private iterableProxy: NgForOf<T>;\n  private _rawItems: T[];\n  private filteredItems: T[];\n  private subscriptions: Subscription[] = [];\n  private filter = '';\n  private _filterField: string;\n  private differ: IterableDiffer<T> | null = null;\n\n  @Input('clrOptionItemsOf')\n  public set rawItems(items: T[]) {\n    this._rawItems = items ? items : [];\n    this.updateItems();\n  }\n\n  @Input('clrOptionItemsTrackBy')\n  set trackBy(value: TrackByFunction<T>) {\n    this.iterableProxy.ngForTrackBy = value;\n  }\n\n  @Input('clrOptionItemsField')\n  public set field(field: string) {\n    this._filterField = field;\n    this.optionService.displayField = field;\n  }\n\n  constructor(\n    public template: TemplateRef<NgForOfContext<T>>,\n    private differs: IterableDiffers,\n    private optionService: OptionSelectionService<T>,\n    private positionService: ClrPopoverPositionService,\n    private vcr: ViewContainerRef\n  ) {\n    this.iterableProxy = new NgForOf<T>(this.vcr, this.template, this.differs);\n    this.subscriptions.push(\n      optionService.inputChanged.subscribe(filter => {\n        this.filter = filter;\n        this.updateItems();\n      })\n    );\n  }\n\n  private updateItems() {\n    if (!this._rawItems || this.filter === undefined || this.filter === null) {\n      return;\n    }\n    if (this._filterField) {\n      this.filteredItems = this._rawItems.filter(item => {\n        const objValue = (item as any)[this._filterField];\n        return objValue ? objValue.toString().toLowerCase().indexOf(this.filter.toLowerCase().toString()) > -1 : false;\n      });\n    } else {\n      // Filter by all item object values\n      this.filteredItems = this._rawItems.filter(item => {\n        if (typeof item !== 'object') {\n          return item.toString().toLowerCase().indexOf(this.filter.toString().toLowerCase()) > -1;\n        }\n        const objValues = Object.values(item).filter(value => {\n          return value !== null && value !== undefined\n            ? value.toString().toLowerCase().indexOf(this.filter.toString().toLowerCase()) > -1\n            : false;\n        });\n        return objValues.length > 0;\n      });\n    }\n    this.iterableProxy.ngForOf = this.filteredItems;\n  }\n\n  ngDoCheck() {\n    if (!this.differ) {\n      this.differ = this.differs.find(this.filteredItems).create(this.iterableProxy.ngForTrackBy);\n    }\n    if (this.differ) {\n      const changes = this.differ.diff(this.filteredItems);\n      if (changes) {\n        this.iterableProxy.ngDoCheck();\n        this.positionService.realign();\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n}\n"]}

package/esm2020/forms/combobox/option-selected.directive.mjs

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClrOptionSelected {
+    constructor(template) {
+        this.template = template;
+    }
+}
+ClrOptionSelected.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptionSelected, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClrOptionSelected.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrOptionSelected, selector: "[clrOptionSelected]", inputs: { selected: ["clrOptionSelected", "selected"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptionSelected, decorators: [{
+            type: Directive,
+            args: [{ selector: '[clrOptionSelected]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { selected: [{
+                type: Input,
+                args: ['clrOptionSelected']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLXNlbGVjdGVkLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL2Zvcm1zL2NvbWJvYm94L29wdGlvbi1zZWxlY3RlZC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFlLE1BQU0sZUFBZSxDQUFDOztBQUc5RCxNQUFNLE9BQU8saUJBQWlCO0lBQzVCLFlBQW1CLFFBQXVDO1FBQXZDLGFBQVEsR0FBUixRQUFRLENBQStCO0lBQUcsQ0FBQzs7OEdBRG5ELGlCQUFpQjtrR0FBakIsaUJBQWlCOzJGQUFqQixpQkFBaUI7a0JBRDdCLFNBQVM7bUJBQUMsRUFBRSxRQUFRLEVBQUUscUJBQXFCLEVBQUU7a0dBSWhCLFFBQVE7c0JBQW5DLEtBQUs7dUJBQUMsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxNi0yMDIxIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICogVGhpcyBzb2Z0d2FyZSBpcyByZWxlYXNlZCB1bmRlciBNSVQgbGljZW5zZS5cbiAqIFRoZSBmdWxsIGxpY2Vuc2UgaW5mb3JtYXRpb24gY2FuIGJlIGZvdW5kIGluIExJQ0VOU0UgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgcHJvamVjdC5cbiAqL1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW2Nsck9wdGlvblNlbGVjdGVkXScgfSlcbmV4cG9ydCBjbGFzcyBDbHJPcHRpb25TZWxlY3RlZDxUPiB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8eyAkaW1wbGljaXQ6IFQgfT4pIHt9XG5cbiAgQElucHV0KCdjbHJPcHRpb25TZWxlY3RlZCcpIHNlbGVjdGVkOiBUO1xufVxuIl19

package/esm2020/forms/combobox/option.mjs

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component, HostBinding, HostListener, Inject, Input } from '@angular/core';
+import { OptionData as OptionProxy } from './providers/combobox-focus-handler.service';
+import { UNIQUE_ID, UNIQUE_ID_PROVIDER } from '../../utils/id-generator/id-generator.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../utils/i18n/common-strings.service";
+import * as i2 from "./providers/combobox-focus-handler.service";
+import * as i3 from "./providers/option-selection.service";
+import * as i4 from "@angular/common";
+export class ClrOption {
+    constructor(elRef, commonStrings, focusHandler, optionSelectionService, autoId) {
+        this.elRef = elRef;
+        this.commonStrings = commonStrings;
+        this.focusHandler = focusHandler;
+        this.optionSelectionService = optionSelectionService;
+        this.autoId = autoId;
+        // A proxy with only the necessary data to be used for a11y and the focus handler service.
+        this.optionProxy = new OptionProxy(null, null);
+        this.optionProxy.el = this.elRef.nativeElement;
+    }
+    set optionId(id) {
+        this._id = id;
+        this.optionProxy.id = this._id;
+    }
+    get optionId() {
+        return this._id;
+    }
+    set value(value) {
+        this._value = value;
+        this.optionProxy.value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    get selected() {
+        return (this.optionSelectionService.selectionModel && this.optionSelectionService.selectionModel.containsItem(this.value));
+    }
+    ngOnInit() {
+        if (!this._id) {
+            this._id = 'clr-option-' + this.autoId;
+            this.optionProxy.id = this._id;
+        }
+    }
+    onClick() {
+        if (this.optionSelectionService.multiselectable) {
+            this.optionSelectionService.toggle(this.value);
+        }
+        else {
+            this.optionSelectionService.select(this.value);
+        }
+        // As the popover stays open in multi-select mode now, we have to take focus back to the input
+        // This way we achieve two things:
+        // - do not lose focus
+        // - we're still able to use onBlur for "outside-click" handling
+        this.focusHandler.focusInput();
+    }
+    get focusClass() {
+        return this.focusHandler.pseudoFocus.containsItem(this.optionProxy);
+    }
+}
+ClrOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOption, deps: [{ token: i0.ElementRef }, { token: i1.ClrCommonStringsService }, { token: i2.ComboboxFocusHandler }, { token: i3.OptionSelectionService }, { token: UNIQUE_ID }], target: i0.ɵɵFactoryTarget.Component });
+ClrOption.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrOption, selector: "clr-option", inputs: { optionId: ["id", "optionId"], value: ["clrValue", "value"] }, host: { listeners: { "click": "onClick()" }, properties: { "class.clr-combobox-option": "true", "attr.role": "\"option\"", "attr.tabindex": "-1", "attr.id": "optionId", "class.active": "this.selected", "class.clr-focus": "this.focusClass" } }, providers: [UNIQUE_ID_PROVIDER], ngImport: i0, template: `<ng-content></ng-content>
+    <span *ngIf="selected" class="clr-sr-only"> {{ commonStrings.keys.comboboxSelected }} </span> `, isInline: true, directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOption, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-option',
+                    template: `<ng-content></ng-content>
+    <span *ngIf="selected" class="clr-sr-only"> {{ commonStrings.keys.comboboxSelected }} </span> `,
+                    providers: [UNIQUE_ID_PROVIDER],
+                    host: {
+                        '[class.clr-combobox-option]': 'true',
+                        '[attr.role]': '"option"',
+                        // Do not remove. Or click-selection will not work.
+                        '[attr.tabindex]': '-1',
+                        '[attr.id]': 'optionId',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ClrCommonStringsService }, { type: i2.ComboboxFocusHandler }, { type: i3.OptionSelectionService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [UNIQUE_ID]
+                }] }]; }, propDecorators: { optionId: [{
+                type: Input,
+                args: ['id']
+            }], value: [{
+                type: Input,
+                args: ['clrValue']
+            }], selected: [{
+                type: HostBinding,
+                args: ['class.active']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], focusClass: [{
+                type: HostBinding,
+                args: ['class.clr-focus']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/forms/combobox/options.mjs

@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component, ContentChildren, Inject, Input, Optional, } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { POPOVER_HOST_ANCHOR } from '../../popover/common/popover-host-anchor.token';
+import { IF_ACTIVE_ID } from '../../utils/conditional/if-active.service';
+import { LoadingListener } from '../../utils/loading/loading-listener';
+import { ClrLoadingState } from '../../utils/loading/loading';
+import { ClrOption } from './option';
+import { fromEvent } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/option-selection.service";
+import * as i2 from "../../utils/aria/aria.service";
+import * as i3 from "../../utils/i18n/common-strings.service";
+import * as i4 from "./providers/combobox-focus-handler.service";
+import * as i5 from "../../utils/popover/providers/popover-toggle.service";
+import * as i6 from "../../progress/spinner/spinner";
+import * as i7 from "@angular/common";
+let nbOptionsComponents = 0;
+export class ClrOptions {
+    constructor(optionSelectionService, id, ariaService, el, commonStrings, focusHandler, toggleService, parentHost, document) {
+        this.optionSelectionService = optionSelectionService;
+        this.id = id;
+        this.ariaService = ariaService;
+        this.el = el;
+        this.commonStrings = commonStrings;
+        this.focusHandler = focusHandler;
+        this.toggleService = toggleService;
+        this.document = document;
+        this.loading = false;
+        this.subscriptions = [];
+        if (!parentHost) {
+            throw new Error('clr-options should only be used inside of a clr-combobox');
+        }
+        if (!this.optionsId) {
+            this.optionsId = 'clr-options-' + nbOptionsComponents++;
+        }
+    }
+    searchText(input) {
+        return this.commonStrings.parse(this.commonStrings.keys.comboboxSearching, { INPUT: input });
+    }
+    /**
+     * Tests if the list of options is empty, meaning it doesn't contain any items
+     */
+    get emptyOptions() {
+        return !this.optionSelectionService.loading && this.items.length === 0;
+    }
+    set optionsId(id) {
+        this.ariaService.ariaControls = id;
+        this.ariaService.ariaOwns = id;
+    }
+    get optionsId() {
+        return this.ariaService.ariaControls;
+    }
+    set items(items) {
+        this._items = items;
+        this.focusHandler.addOptionValues(this._items.map(option => option.optionProxy));
+    }
+    get items() {
+        return this._items;
+    }
+    loadingStateChange(state) {
+        this.loading = state === ClrLoadingState.LOADING;
+    }
+    ngAfterViewInit() {
+        this.focusHandler.listbox = this.el.nativeElement;
+        this.subscriptions.push(fromEvent(this.document, 'scroll', { capture: true }).subscribe(event => {
+            if (this.toggleService.open &&
+                event.target !== this.el.nativeElement &&
+                event.target !== this.focusHandler.textInput) {
+                this.toggleService.open = false;
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrOptions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptions, deps: [{ token: i1.OptionSelectionService }, { token: IF_ACTIVE_ID }, { token: i2.AriaService }, { token: i0.ElementRef }, { token: i3.ClrCommonStringsService }, { token: i4.ComboboxFocusHandler }, { token: i5.ClrPopoverToggleService }, { token: POPOVER_HOST_ANCHOR, optional: true }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+ClrOptions.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrOptions, selector: "clr-options", inputs: { optionsId: ["id", "optionsId"] }, host: { properties: { "class.clr-combobox-options": "true", "attr.role": "\"listbox\"", "id": "optionsId" } }, providers: [{ provide: LoadingListener, useExisting: ClrOptions }], queries: [{ propertyName: "items", predicate: ClrOption }], ngImport: i0, template: `
+    <div *ngIf="optionSelectionService.loading" class="clr-combobox-options-loading">
+      <clr-spinner clrInline>
+        {{ commonStrings.keys.loading }}
+      </clr-spinner>
+      <span class="clr-combobox-options-text">
+        {{ searchText(optionSelectionService.currentInput) }}
+      </span>
+    </div>
+
+    <!-- Rendered if data set is empty -->
+    <div *ngIf="emptyOptions">
+      <span class="clr-combobox-options-empty-text">
+        {{ commonStrings.keys.comboboxNoResults }}
+      </span>
+    </div>
+
+    <!--Option Groups and Options will be projected here-->
+    <ng-content></ng-content>
+  `, isInline: true, components: [{ type: i6.ClrSpinner, selector: "clr-spinner", inputs: ["clrInline", "clrInverse", "clrSmall", "clrMedium"] }], directives: [{ type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrOptions, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-options',
+                    template: `
+    <div *ngIf="optionSelectionService.loading" class="clr-combobox-options-loading">
+      <clr-spinner clrInline>
+        {{ commonStrings.keys.loading }}
+      </clr-spinner>
+      <span class="clr-combobox-options-text">
+        {{ searchText(optionSelectionService.currentInput) }}
+      </span>
+    </div>
+
+    <!-- Rendered if data set is empty -->
+    <div *ngIf="emptyOptions">
+      <span class="clr-combobox-options-empty-text">
+        {{ commonStrings.keys.comboboxNoResults }}
+      </span>
+    </div>
+
+    <!--Option Groups and Options will be projected here-->
+    <ng-content></ng-content>
+  `,
+                    providers: [{ provide: LoadingListener, useExisting: ClrOptions }],
+                    host: {
+                        '[class.clr-combobox-options]': 'true',
+                        '[attr.role]': '"listbox"',
+                        '[id]': 'optionsId',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OptionSelectionService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IF_ACTIVE_ID]
+                }] }, { type: i2.AriaService }, { type: i0.ElementRef }, { type: i3.ClrCommonStringsService }, { type: i4.ComboboxFocusHandler }, { type: i5.ClrPopoverToggleService }, { type: i0.ElementRef, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [POPOVER_HOST_ANCHOR]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { optionsId: [{
+                type: Input,
+                args: ['id']
+            }], items: [{
+                type: ContentChildren,
+                args: [ClrOption]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../projects/angular/src/forms/combobox/options.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport {\n  Component,\n  ContentChildren,\n  ElementRef,\n  Inject,\n  Input,\n  Optional,\n  QueryList,\n  AfterViewInit,\n  OnDestroy,\n} from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { POPOVER_HOST_ANCHOR } from '../../popover/common/popover-host-anchor.token';\nimport { OptionSelectionService } from './providers/option-selection.service';\nimport { IF_ACTIVE_ID } from '../../utils/conditional/if-active.service';\nimport { AriaService } from '../../utils/aria/aria.service';\nimport { ClrCommonStringsService } from '../../utils/i18n/common-strings.service';\nimport { LoadingListener } from '../../utils/loading/loading-listener';\nimport { ClrLoadingState } from '../../utils/loading/loading';\nimport { ClrOption } from './option';\nimport { ComboboxFocusHandler } from './providers/combobox-focus-handler.service';\nimport { fromEvent, Subscription } from 'rxjs';\nimport { ClrPopoverToggleService } from '../../utils/popover/providers/popover-toggle.service';\n\nlet nbOptionsComponents = 0;\n\n@Component({\n  selector: 'clr-options',\n  template: `\n    <div *ngIf=\"optionSelectionService.loading\" class=\"clr-combobox-options-loading\">\n      <clr-spinner clrInline>\n        {{ commonStrings.keys.loading }}\n      </clr-spinner>\n      <span class=\"clr-combobox-options-text\">\n        {{ searchText(optionSelectionService.currentInput) }}\n      </span>\n    </div>\n\n    <!-- Rendered if data set is empty -->\n    <div *ngIf=\"emptyOptions\">\n      <span class=\"clr-combobox-options-empty-text\">\n        {{ commonStrings.keys.comboboxNoResults }}\n      </span>\n    </div>\n\n    <!--Option Groups and Options will be projected here-->\n    <ng-content></ng-content>\n  `,\n  providers: [{ provide: LoadingListener, useExisting: ClrOptions }],\n  host: {\n    '[class.clr-combobox-options]': 'true',\n    '[attr.role]': '\"listbox\"',\n    '[id]': 'optionsId',\n  },\n})\nexport class ClrOptions<T> implements AfterViewInit, LoadingListener, OnDestroy {\n  public loading = false;\n  private subscriptions: Subscription[] = [];\n\n  constructor(\n    public optionSelectionService: OptionSelectionService<T>,\n    @Inject(IF_ACTIVE_ID) public id: number,\n    private ariaService: AriaService,\n    private el: ElementRef,\n    public commonStrings: ClrCommonStringsService,\n    private focusHandler: ComboboxFocusHandler<T>,\n    private toggleService: ClrPopoverToggleService,\n    @Optional()\n    @Inject(POPOVER_HOST_ANCHOR)\n    parentHost: ElementRef,\n    @Inject(DOCUMENT) private document: any\n  ) {\n    if (!parentHost) {\n      throw new Error('clr-options should only be used inside of a clr-combobox');\n    }\n\n    if (!this.optionsId) {\n      this.optionsId = 'clr-options-' + nbOptionsComponents++;\n    }\n  }\n\n  public searchText(input: string) {\n    return this.commonStrings.parse(this.commonStrings.keys.comboboxSearching, { INPUT: input });\n  }\n\n  /**\n   * Tests if the list of options is empty, meaning it doesn't contain any items\n   */\n  public get emptyOptions() {\n    return !this.optionSelectionService.loading && this.items.length === 0;\n  }\n\n  @Input('id')\n  set optionsId(id: string) {\n    this.ariaService.ariaControls = id;\n    this.ariaService.ariaOwns = id;\n  }\n\n  get optionsId(): string {\n    return this.ariaService.ariaControls;\n  }\n\n  _items: QueryList<ClrOption<T>>;\n  @ContentChildren(ClrOption)\n  set items(items: QueryList<ClrOption<T>>) {\n    this._items = items;\n    this.focusHandler.addOptionValues(this._items.map(option => option.optionProxy));\n  }\n\n  get items(): QueryList<ClrOption<T>> {\n    return this._items;\n  }\n\n  loadingStateChange(state: ClrLoadingState): void {\n    this.loading = state === ClrLoadingState.LOADING;\n  }\n\n  ngAfterViewInit() {\n    this.focusHandler.listbox = this.el.nativeElement;\n\n    this.subscriptions.push(\n      fromEvent(this.document, 'scroll', { capture: true }).subscribe(event => {\n        if (\n          this.toggleService.open &&\n          (event as Event).target !== this.el.nativeElement &&\n          (event as Event).target !== this.focusHandler.textInput\n        ) {\n          this.toggleService.open = false;\n        }\n      })\n    );\n  }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n}\n"]}

package/esm2020/forms/combobox/providers/combobox-container.service.mjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ComboboxContainerService {
+    constructor() {
+        this.labelOffset = 0;
+    }
+}
+ComboboxContainerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ComboboxContainerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ComboboxContainerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ComboboxContainerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ComboboxContainerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tYm9ib3gtY29udGFpbmVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyL3NyYy9mb3Jtcy9jb21ib2JveC9wcm92aWRlcnMvY29tYm9ib3gtY29udGFpbmVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRzNDLE1BQU0sT0FBTyx3QkFBd0I7SUFEckM7UUFFRSxnQkFBVyxHQUFHLENBQUMsQ0FBQztLQUVqQjs7cUhBSFksd0JBQXdCO3lIQUF4Qix3QkFBd0I7MkZBQXhCLHdCQUF3QjtrQkFEcEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMSBWTXdhcmUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqIFRoaXMgc29mdHdhcmUgaXMgcmVsZWFzZWQgdW5kZXIgTUlUIGxpY2Vuc2UuXG4gKiBUaGUgZnVsbCBsaWNlbnNlIGluZm9ybWF0aW9uIGNhbiBiZSBmb3VuZCBpbiBMSUNFTlNFIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHByb2plY3QuXG4gKi9cbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENvbWJvYm94Q29udGFpbmVyU2VydmljZSB7XG4gIGxhYmVsT2Zmc2V0ID0gMDtcbiAgbGFiZWxUZXh0OiBzdHJpbmc7XG59XG4iXX0=