@covalent/core 6.4.0 → 6.4.2

package/breadcrumbs/breadcrumbs.component.d.ts

@@ -30,5 +30,5 @@ export declare class TdBreadcrumbsComponent implements OnInit, AfterContentInit,
     private setCrumbIcons;
     private _calculateVisibility;
     static ɵfac: i0.ɵɵFactoryDeclaration<TdBreadcrumbsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TdBreadcrumbsComponent, "td-breadcrumbs", never, { "separatorIcon": { "alias": "separatorIcon"; "required": false; }; }, {}, ["_breadcrumbs"], ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdBreadcrumbsComponent, "td-breadcrumbs", never, { "separatorIcon": "separatorIcon"; }, {}, ["_breadcrumbs"], ["*"], false, never>;
 }

package/common/styles/font/_font.scss

@@ -1,41 +1,7 @@
 $mat-font-url: 'styles/font/' !default;
 
 @mixin covalent-material-icons() {
-  @font-face {
-    font-family: 'Material Icons';
-    font-style: normal;
-    font-weight: 400;
-    src: url($mat-font-url + 'MaterialIcons-Regular-v48.woff2') format('woff2');
-  }
-
-  .material-icons {
-    /* stylelint-disable-next-line font-family-no-missing-generic-family-keyword */
-    font-family: 'Material Icons';
-    font-weight: normal;
-    font-style: normal;
-    font-size: 24px; /* Preferred icon size */
-    display: inline-block;
-    width: 1em;
-    height: 1em;
-    line-height: 1;
-    text-transform: none;
-    letter-spacing: normal;
-    word-wrap: normal;
-    white-space: nowrap;
-    direction: ltr;
-
-    /* Support for all WebKit browsers. */
-    -webkit-font-smoothing: antialiased;
-
-    /* Support for Safari and Chrome. */
-    text-rendering: optimizeLegibility;
-
-    /* Support for Firefox. */
-    -moz-osx-font-smoothing: grayscale;
-
-    /* Support for IE. */
-    font-feature-settings: 'liga';
-  }
+  @import url('https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200&display=block');
 
   // Ensure our size prevails over material
   mat-icon.material-icons {

package/dialogs/src/README.md

@@ -0,0 +1,223 @@
+# TdDialogService
+
+Service provided with methods that wrap the @angular/material [MatDialog] service and provide an easier experience for simple dialogs.
+
+Note: if no [ViewContainerRef] is provided, [TdDialogService] will throw an error.
+
+<br/>
+
+## API Summary
+
+#### Methods
+
+- openAlert: function(IAlertConfig): MatDialogRef<TdAlertDialogComponent>
+  - Opens an alert dialog with the provided config.
+- openConfirm: function(IConfirmConfig): MatDialogRef<TdConfirmDialogComponent>
+  - Opens a confirm dialog with the provided config.
+- openPrompt: function(IPromptConfig): MatDialogRef<TdPromptDialogComponent>
+  - Opens a prompt dialog with the provided config.
+- open: function<T>(component: ComponentType<T>, config: MatDialogConfig): MatDialogRef<T>
+  - Wrapper function over the open() method in MatDialog. Opens a modal dialog containing the given component.
+- openDraggable: function<T>(IDraggableConfig<T>): MatDialogRef<T>
+  - Opens a draggable dialog containing the given component
+- closeAll: function()
+  - Wrapper function over the closeAll() method in MatDialog. Closes all of the currently-open dialogs.
+
+## Usage
+
+TypeScript
+
+```typescript
+import { ViewContainerRef } from '@angular/core';
+import { TdDialogService } from '@covalent/core/dialogs';
+...
+})
+export class Demo {
+  constructor(private _dialogService: TdDialogService,
+              private _viewContainerRef: ViewContainerRef) {
+    ...
+  }
+
+  openAlert(): void {
+    this._dialogService.openAlert({
+      message: 'This is how simple it is to create an alert with this wrapper service.',
+      disableClose: true | false, // defaults to false
+      viewContainerRef: this._viewContainerRef, //OPTIONAL
+      title: 'Alert', //OPTIONAL, hides if not provided
+      closeButton: 'Close', //OPTIONAL, defaults to 'CLOSE'
+      width: '400px', //OPTIONAL, defaults to 400px
+    });
+  }
+
+  openConfirm(): void {
+    this._dialogService.openConfirm({
+      message: 'This is how simple it is to create a confirm with this wrapper service. Do you agree?',
+      disableClose: true | false, // defaults to false
+      viewContainerRef: this._viewContainerRef, //OPTIONAL
+      title: 'Confirm', //OPTIONAL, hides if not provided
+      cancelButton: 'Disagree', //OPTIONAL, defaults to 'CANCEL'
+      acceptButton: 'Agree', //OPTIONAL, defaults to 'ACCEPT'
+      isDestructive: false, //OPTIONAL, defaults to false
+      width: '500px', //OPTIONAL, defaults to 400px
+    }).afterClosed().subscribe((accept: boolean) => {
+      if (accept) {
+        // DO SOMETHING
+      } else {
+        // DO SOMETHING ELSE
+      }
+    });
+  }
+
+  openPrompt(): void {
+    this._dialogService.openPrompt({
+      message: 'This is how simple it is to create a prompt with this wrapper service. Prompt something.',
+      disableClose: true | false, // defaults to false
+      viewContainerRef: this._viewContainerRef, //OPTIONAL
+      title: 'Prompt', //OPTIONAL, hides if not provided
+      value: 'Prepopulated value', //OPTIONAL
+      cancelButton: 'Cancel', //OPTIONAL, defaults to 'CANCEL'
+      acceptButton: 'Ok', //OPTIONAL, defaults to 'ACCEPT'
+      width: '400px', //OPTIONAL, defaults to 400px
+    }).afterClosed().subscribe((newValue: string) => {
+      if (newValue) {
+        // DO SOMETHING
+      } else {
+        // DO SOMETHING ELSE
+      }
+    });
+  }
+
+  openDraggable(): void {
+    this._dialogService.openDraggable({
+      component: DraggableDemoComponent,
+      config: { height: '300px' },
+      // CSS selectors of element(s) inside the component meant to be drag handle(s)
+      dragHandleSelectors: ['.drag-handle'],
+      // Class that will be added to the component signifying drag-ability
+      draggableClass: 'custom-class',
+    });
+  }
+}
+```
+
+```typescript
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-draggable-demo',
+  template: `
+    <h2>Draggable dialog</h2>
+    <p>Draggable via the drag handle</p>
+    <button mat-icon-button class="drag-handle">
+      <mat-icon>drag_handle</mat-icon>
+    </button>
+  `,
+})
+export class DraggableDemoComponent {}
+```
+
+## Setup
+
+Import the [CovalentDialogsModule] in your NgModule:
+
+```typescript
+import { CovalentDialogsModule } from '@covalent/core/dialogs';
+
+@NgModule({
+  imports: [
+    CovalentDialogsModule,
+    ...
+  ],
+  ...
+})
+export class MyModule {}
+```
+
+After that, just inject [TdDialogService] and use it for your dialogs.
+
+# ResizableDraggableDialog
+
+A utility to make a draggable dialog resizable.
+
+## Usage
+
+```ts
+ constructor(
+    private _dialogService: TdDialogService,
+    @Inject(DOCUMENT) private _document: any,
+    private _renderer2: Renderer2,
+  ) {}
+```
+
+```ts
+const {
+  matDialogRef,
+  dragRefSubject,
+}: IDraggableRefs<DraggableResizableDialogComponent> = this._dialogService.openDraggable(
+  {
+    component: DraggableResizableDialogComponent,
+    // CSS selectors of element(s) inside the component meant to be drag handle(s)
+    dragHandleSelectors: ['.drag-handle'],
+  }
+);
+
+let resizableDraggableDialog: ResizableDraggableDialog;
+dragRefSubject.subscribe((dragRf: DragRef) => {
+  resizableDraggableDialog = new ResizableDraggableDialog(
+    this._document,
+    this._renderer2,
+    matDialogRef,
+    dragRf
+  );
+});
+
+// Detach resize-ability event listeners after dialog closes
+matDialogRef.afterClosed().subscribe(() => resizableDraggableDialog.detach());
+```
+
+# TdWindowDialogComponent
+
+A component that can be utilized to create a dialog with a toolbar
+
+## API Summary
+
+#### Inputs
+
+- title: string
+  - Title that appears in toolbar
+- closeLabel: string
+  - Label to be used on close button
+- toolbarColor: ThemePalette
+  - Toolbar color
+
+#### Outputs
+
+- closed: string
+  - Emitted when close button is clicked
+
+## Usage
+
+```ts
+@Component({
+  template: `
+    <td-window-dialog
+      [title]="'Title'"
+      [toolbarColor]="'accent'"
+      [closeLabel]="'Close'"
+      (closed)="closed.emit()"
+    >
+      <p>Comes with a handy toolbar</p>
+    </td-window-dialog>
+  `,
+})
+export class DraggableResizableWindowDialogComponent {
+  @Output() closed: EventEmitter<void> = new EventEmitter();
+}
+```
+
+```ts
+const matDialogRef: MatDialogRef<DraggableResizableWindowDialogComponent> =
+  this._dialogService.open(DraggableResizableWindowDialogComponent);
+// listen to close event
+matDialogRef.componentInstance.closed.subscribe(() => matDialogRef.close());
+```

package/dialogs/window-dialog/window-dialog.component.d.ts

@@ -12,5 +12,5 @@ export declare class TdWindowDialogComponent {
     toolbarHeight: number;
     toggleDockedState(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TdWindowDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TdWindowDialogComponent, "td-window-dialog", never, { "toolbarColor": { "alias": "toolbarColor"; "required": false; }; "docked": { "alias": "docked"; "required": false; }; "title": { "alias": "title"; "required": false; }; "toggleDockedStateLabel": { "alias": "toggleDockedStateLabel"; "required": false; }; "closeLabel": { "alias": "closeLabel"; "required": false; }; }, { "dockToggled": "dockToggled"; "closed": "closed"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdWindowDialogComponent, "td-window-dialog", never, { "toolbarColor": "toolbarColor"; "docked": "docked"; "title": "title"; "toggleDockedStateLabel": "toggleDockedStateLabel"; "closeLabel": "closeLabel"; }, { "dockToggled": "dockToggled"; "closed": "closed"; }, never, ["*"], false, never>;
 }

package/dynamic-menu/dynamic-menu-item/dynamic-menu-item.component.d.ts

@@ -8,5 +8,5 @@ export declare class TdDynamicMenuItemComponent {
     childMenu: MatMenu;
     emitClicked(event: ITdDynamicMenuLinkClickEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TdDynamicMenuItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuItemComponent, "td-dynamic-menu-item", never, { "items": { "alias": "items"; "required": false; }; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuItemComponent, "td-dynamic-menu-item", never, { "items": "items"; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
 }

package/dynamic-menu/dynamic-menu-item/dynamic-menu-link/dynamic-menu-link.component.d.ts

@@ -6,5 +6,5 @@ export declare class TdDynamicMenuLinkComponent {
     itemClicked: EventEmitter<ITdDynamicMenuLinkClickEvent>;
     emitClicked(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TdDynamicMenuLinkComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuLinkComponent, "td-dynamic-menu-link", never, { "item": { "alias": "item"; "required": false; }; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuLinkComponent, "td-dynamic-menu-link", never, { "item": "item"; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
 }

package/dynamic-menu/dynamic-menu.component.d.ts

@@ -7,5 +7,5 @@ export declare class TdDynamicMenuComponent {
     itemClicked: EventEmitter<ITdDynamicMenuLinkClickEvent>;
     emitClicked(event: ITdDynamicMenuLinkClickEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TdDynamicMenuComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuComponent, "td-dynamic-menu", never, { "trigger": { "alias": "trigger"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdDynamicMenuComponent, "td-dynamic-menu", never, { "trigger": "trigger"; "items": "items"; }, { "itemClicked": "itemClicked"; }, never, never, false, never>;
 }

package/esm2020/breadcrumbs/breadcrumb/breadcrumb.component.mjs

@@ -0,0 +1,92 @@
+import { Component, ElementRef, HostBinding, ChangeDetectionStrategy, ChangeDetectorRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/icon";
+export class TdBreadcrumbComponent {
+    // Sets the icon url shown between breadcrumbs. Defaults to 'chevron_right'
+    get separatorIcon() {
+        return this._separatorIcon;
+    }
+    set separatorIcon(separatorIcon) {
+        this._separatorIcon = separatorIcon;
+        setTimeout(() => {
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    // Should show the right chevron or not before the label
+    get displayIcon() {
+        return this._displayIcon;
+    }
+    set displayIcon(displayIcon) {
+        this._displayIcon = displayIcon;
+        setTimeout(() => {
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    get displayCrumb() {
+        return this._displayCrumb;
+    }
+    /**
+     * Whether to display the crumb or not
+     */
+    set displayCrumb(shouldDisplay) {
+        this._displayCrumb = shouldDisplay;
+        setTimeout(() => {
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    /**
+     * Width of the DOM element of the crumb
+     */
+    get width() {
+        return this._width;
+    }
+    /**
+     * Gets the display style of the crumb
+     */
+    get displayBinding() {
+        // Set the display to none on the component, just in case the end user is hiding
+        // and showing them instead of the component doing itself for reasons like responsive
+        return this._displayCrumb ? undefined : 'none';
+    }
+    constructor(_elementRef, _changeDetectorRef) {
+        this._elementRef = _elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._displayCrumb = true;
+        this._width = 0;
+        this._displayIcon = true;
+        this._separatorIcon = 'chevron_right';
+        this.matButtonClass = true;
+        this.tdBreadCrumbClass = true;
+    }
+    ngAfterViewInit() {
+        // set the width from the actual rendered DOM element
+        setTimeout(() => {
+            this._width = (this._elementRef.nativeElement).getBoundingClientRect().width;
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    /**
+     * Stop click propagation when clicking on icon
+     */
+    _handleIconClick(event) {
+        event.stopPropagation();
+        event.preventDefault();
+    }
+}
+TdBreadcrumbComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBreadcrumbComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TdBreadcrumbComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdBreadcrumbComponent, selector: "td-breadcrumb, a[td-breadcrumb]", host: { properties: { "class.mdc-button": "this.matButtonClass", "class.td-breadcrumb": "this.tdBreadCrumbClass", "style.display": "this.displayBinding" } }, ngImport: i0, template: "<ng-content></ng-content>\n<mat-icon\n  *ngIf=\"displayIcon\"\n  class=\"td-breadcrumb-separator-icon\"\n  [style.cursor]=\"'default'\"\n  (click)=\"_handleIconClick($event)\"\n  >{{ separatorIcon }}</mat-icon\n>\n", styles: [":host.td-breadcrumb{display:inline-block;box-sizing:border-box;flex-direction:row;align-items:center;align-content:center;max-width:100%;justify-content:flex-end}:host.td-breadcrumb ::ng-deep>*{margin:0 10px}:host .td-breadcrumb-separator-icon{display:inline-flex;vertical-align:middle}:host.mat-button{min-width:0;padding:0}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'td-breadcrumb, a[td-breadcrumb]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n<mat-icon\n  *ngIf=\"displayIcon\"\n  class=\"td-breadcrumb-separator-icon\"\n  [style.cursor]=\"'default'\"\n  (click)=\"_handleIconClick($event)\"\n  >{{ separatorIcon }}</mat-icon\n>\n", styles: [":host.td-breadcrumb{display:inline-block;box-sizing:border-box;flex-direction:row;align-items:center;align-content:center;max-width:100%;justify-content:flex-end}:host.td-breadcrumb ::ng-deep>*{margin:0 10px}:host .td-breadcrumb-separator-icon{display:inline-flex;vertical-align:middle}:host.mat-button{min-width:0;padding:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { matButtonClass: [{
+                type: HostBinding,
+                args: ['class.mdc-button']
+            }], tdBreadCrumbClass: [{
+                type: HostBinding,
+                args: ['class.td-breadcrumb']
+            }], displayBinding: [{
+                type: HostBinding,
+                args: ['style.display']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvYnJlYWRjcnVtYnMvc3JjL2JyZWFkY3J1bWIvYnJlYWRjcnVtYi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvYnJlYWRjcnVtYnMvc3JjL2JyZWFkY3J1bWIvYnJlYWRjcnVtYi5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsU0FBUyxFQUNULFVBQVUsRUFDVixXQUFXLEVBRVgsdUJBQXVCLEVBQ3ZCLGlCQUFpQixHQUNsQixNQUFNLGVBQWUsQ0FBQzs7OztBQVF2QixNQUFNLE9BQU8scUJBQXFCO0lBU2hDLDJFQUEyRTtJQUMzRSxJQUFXLGFBQWE7UUFDdEIsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDO0lBQzdCLENBQUM7SUFDRCxJQUFXLGFBQWEsQ0FBQyxhQUFxQjtRQUM1QyxJQUFJLENBQUMsY0FBYyxHQUFHLGFBQWEsQ0FBQztRQUNwQyxVQUFVLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3pDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELHdEQUF3RDtJQUN4RCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDO0lBQzNCLENBQUM7SUFDRCxJQUFXLFdBQVcsQ0FBQyxXQUFvQjtRQUN6QyxJQUFJLENBQUMsWUFBWSxHQUFHLFdBQVcsQ0FBQztRQUNoQyxVQUFVLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3pDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELElBQUksWUFBWTtRQUNkLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQztJQUM1QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLFlBQVksQ0FBQyxhQUFzQjtRQUNyQyxJQUFJLENBQUMsYUFBYSxHQUFHLGFBQWEsQ0FBQztRQUNuQyxVQUFVLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3pDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsSUFBSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3JCLENBQUM7SUFFRDs7T0FFRztJQUNILElBQ0ksY0FBYztRQUNoQixnRkFBZ0Y7UUFDaEYscUZBQXFGO1FBQ3JGLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDakQsQ0FBQztJQUVELFlBQ1UsV0FBdUIsRUFDdkIsa0JBQXFDO1FBRHJDLGdCQUFXLEdBQVgsV0FBVyxDQUFZO1FBQ3ZCLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBbUI7UUEvRHZDLGtCQUFhLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLFdBQU0sR0FBRyxDQUFDLENBQUM7UUFDWCxpQkFBWSxHQUFHLElBQUksQ0FBQztRQUNwQixtQkFBYyxHQUFHLGVBQWUsQ0FBQztRQUVSLG1CQUFjLEdBQUcsSUFBSSxDQUFDO1FBQ25CLHNCQUFpQixHQUFHLElBQUksQ0FBQztJQTBEMUQsQ0FBQztJQUVKLGVBQWU7UUFDYixxREFBcUQ7UUFDckQsVUFBVSxDQUFDLEdBQUcsRUFBRTtZQUNkLElBQUksQ0FBQyxNQUFNLEdBQWlCLENBQzFCLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUM5QixDQUFDLHFCQUFxQixFQUFFLENBQUMsS0FBSyxDQUFDO1lBQ2pDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUN6QyxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRDs7T0FFRztJQUNILGdCQUFnQixDQUFDLEtBQVk7UUFDM0IsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQ3hCLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztJQUN6QixDQUFDOzttSEFuRlUscUJBQXFCO3VHQUFyQixxQkFBcUIscU9DZmxDLHdOQVFBOzRGRE9hLHFCQUFxQjtrQkFOakMsU0FBUzsrQkFDRSxpQ0FBaUMsbUJBRzFCLHVCQUF1QixDQUFDLE1BQU07aUlBUWQsY0FBYztzQkFBOUMsV0FBVzt1QkFBQyxrQkFBa0I7Z0JBQ0ssaUJBQWlCO3NCQUFwRCxXQUFXO3VCQUFDLHFCQUFxQjtnQkFpRDlCLGNBQWM7c0JBRGpCLFdBQVc7dUJBQUMsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENvbXBvbmVudCxcbiAgRWxlbWVudFJlZixcbiAgSG9zdEJpbmRpbmcsXG4gIEFmdGVyVmlld0luaXQsXG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDaGFuZ2VEZXRlY3RvclJlZixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3RkLWJyZWFkY3J1bWIsIGFbdGQtYnJlYWRjcnVtYl0nLFxuICBzdHlsZVVybHM6IFsnLi9icmVhZGNydW1iLmNvbXBvbmVudC5zY3NzJ10sXG4gIHRlbXBsYXRlVXJsOiAnLi9icmVhZGNydW1iLmNvbXBvbmVudC5odG1sJyxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIFRkQnJlYWRjcnVtYkNvbXBvbmVudCBpbXBsZW1lbnRzIEFmdGVyVmlld0luaXQge1xuICBwcml2YXRlIF9kaXNwbGF5Q3J1bWIgPSB0cnVlO1xuICBwcml2YXRlIF93aWR0aCA9IDA7XG4gIHByaXZhdGUgX2Rpc3BsYXlJY29uID0gdHJ1ZTtcbiAgcHJpdmF0ZSBfc2VwYXJhdG9ySWNvbiA9ICdjaGV2cm9uX3JpZ2h0JztcblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzLm1kYy1idXR0b24nKSBtYXRCdXR0b25DbGFzcyA9IHRydWU7XG4gIEBIb3N0QmluZGluZygnY2xhc3MudGQtYnJlYWRjcnVtYicpIHRkQnJlYWRDcnVtYkNsYXNzID0gdHJ1ZTtcblxuICAvLyBTZXRzIHRoZSBpY29uIHVybCBzaG93biBiZXR3ZWVuIGJyZWFkY3J1bWJzLiBEZWZhdWx0cyB0byAnY2hldnJvbl9yaWdodCdcbiAgcHVibGljIGdldCBzZXBhcmF0b3JJY29uKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuX3NlcGFyYXRvckljb247XG4gIH1cbiAgcHVibGljIHNldCBzZXBhcmF0b3JJY29uKHNlcGFyYXRvckljb246IHN0cmluZykge1xuICAgIHRoaXMuX3NlcGFyYXRvckljb24gPSBzZXBhcmF0b3JJY29uO1xuICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgdGhpcy5fY2hhbmdlRGV0ZWN0b3JSZWYubWFya0ZvckNoZWNrKCk7XG4gICAgfSk7XG4gIH1cblxuICAvLyBTaG91bGQgc2hvdyB0aGUgcmlnaHQgY2hldnJvbiBvciBub3QgYmVmb3JlIHRoZSBsYWJlbFxuICBwdWJsaWMgZ2V0IGRpc3BsYXlJY29uKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLl9kaXNwbGF5SWNvbjtcbiAgfVxuICBwdWJsaWMgc2V0IGRpc3BsYXlJY29uKGRpc3BsYXlJY29uOiBib29sZWFuKSB7XG4gICAgdGhpcy5fZGlzcGxheUljb24gPSBkaXNwbGF5SWNvbjtcbiAgICBzZXRUaW1lb3V0KCgpID0+IHtcbiAgICAgIHRoaXMuX2NoYW5nZURldGVjdG9yUmVmLm1hcmtGb3JDaGVjaygpO1xuICAgIH0pO1xuICB9XG5cbiAgZ2V0IGRpc3BsYXlDcnVtYigpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5fZGlzcGxheUNydW1iO1xuICB9XG5cbiAgLyoqXG4gICAqIFdoZXRoZXIgdG8gZGlzcGxheSB0aGUgY3J1bWIgb3Igbm90XG4gICAqL1xuICBzZXQgZGlzcGxheUNydW1iKHNob3VsZERpc3BsYXk6IGJvb2xlYW4pIHtcbiAgICB0aGlzLl9kaXNwbGF5Q3J1bWIgPSBzaG91bGREaXNwbGF5O1xuICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgdGhpcy5fY2hhbmdlRGV0ZWN0b3JSZWYubWFya0ZvckNoZWNrKCk7XG4gICAgfSk7XG4gIH1cblxuICAvKipcbiAgICogV2lkdGggb2YgdGhlIERPTSBlbGVtZW50IG9mIHRoZSBjcnVtYlxuICAgKi9cbiAgZ2V0IHdpZHRoKCk6IG51bWJlciB7XG4gICAgcmV0dXJuIHRoaXMuX3dpZHRoO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIGRpc3BsYXkgc3R5bGUgb2YgdGhlIGNydW1iXG4gICAqL1xuICBASG9zdEJpbmRpbmcoJ3N0eWxlLmRpc3BsYXknKVxuICBnZXQgZGlzcGxheUJpbmRpbmcoKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgICAvLyBTZXQgdGhlIGRpc3BsYXkgdG8gbm9uZSBvbiB0aGUgY29tcG9uZW50LCBqdXN0IGluIGNhc2UgdGhlIGVuZCB1c2VyIGlzIGhpZGluZ1xuICAgIC8vIGFuZCBzaG93aW5nIHRoZW0gaW5zdGVhZCBvZiB0aGUgY29tcG9uZW50IGRvaW5nIGl0c2VsZiBmb3IgcmVhc29ucyBsaWtlIHJlc3BvbnNpdmVcbiAgICByZXR1cm4gdGhpcy5fZGlzcGxheUNydW1iID8gdW5kZWZpbmVkIDogJ25vbmUnO1xuICB9XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBfZWxlbWVudFJlZjogRWxlbWVudFJlZixcbiAgICBwcml2YXRlIF9jaGFuZ2VEZXRlY3RvclJlZjogQ2hhbmdlRGV0ZWN0b3JSZWZcbiAgKSB7fVxuXG4gIG5nQWZ0ZXJWaWV3SW5pdCgpOiB2b2lkIHtcbiAgICAvLyBzZXQgdGhlIHdpZHRoIGZyb20gdGhlIGFjdHVhbCByZW5kZXJlZCBET00gZWxlbWVudFxuICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgdGhpcy5fd2lkdGggPSAoPEhUTUxFbGVtZW50PihcbiAgICAgICAgdGhpcy5fZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50XG4gICAgICApKS5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS53aWR0aDtcbiAgICAgIHRoaXMuX2NoYW5nZURldGVjdG9yUmVmLm1hcmtGb3JDaGVjaygpO1xuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIFN0b3AgY2xpY2sgcHJvcGFnYXRpb24gd2hlbiBjbGlja2luZyBvbiBpY29uXG4gICAqL1xuICBfaGFuZGxlSWNvbkNsaWNrKGV2ZW50OiBFdmVudCk6IHZvaWQge1xuICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xuICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7XG4gIH1cbn1cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbjxtYXQtaWNvblxuICAqbmdJZj1cImRpc3BsYXlJY29uXCJcbiAgY2xhc3M9XCJ0ZC1icmVhZGNydW1iLXNlcGFyYXRvci1pY29uXCJcbiAgW3N0eWxlLmN1cnNvcl09XCInZGVmYXVsdCdcIlxuICAoY2xpY2spPVwiX2hhbmRsZUljb25DbGljaygkZXZlbnQpXCJcbiAgPnt7IHNlcGFyYXRvckljb24gfX08L21hdC1pY29uXG4+XG4iXX0=

package/esm2020/breadcrumbs/breadcrumbs.component.mjs

@@ -0,0 +1,131 @@
+import { Component, ContentChildren, QueryList, ChangeDetectionStrategy, ChangeDetectorRef, ElementRef, Input, HostBinding, } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { debounceTime, startWith, takeUntil } from 'rxjs/operators';
+import { TdBreadcrumbComponent } from './breadcrumb/breadcrumb.component';
+import * as i0 from "@angular/core";
+export class TdBreadcrumbsComponent {
+    /**
+     * Sets the icon url shown between breadcrumbs. Defaults to 'chevron_right'.
+     */
+    set separatorIcon(separatorIcon) {
+        this._separatorIcon = separatorIcon;
+        this.setCrumbIcons();
+    }
+    get separatorIcon() {
+        return this._separatorIcon;
+    }
+    constructor(_elementRef, _changeDetectorRef) {
+        this._elementRef = _elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._resizing = false;
+        this._separatorIcon = 'chevron_right';
+        this._destroy$ = new Subject();
+        this.tdBreadCrumbsClass = true;
+        // the list of hidden breadcrumbs not shown right now (responsive)
+        this.hiddenBreadcrumbs = [];
+    }
+    ngOnInit() {
+        fromEvent(window, 'resize')
+            .pipe(debounceTime(10), takeUntil(this._destroy$))
+            .subscribe(() => {
+            if (!this._resizing) {
+                this._resizing = true;
+                setTimeout(() => {
+                    this._calculateVisibility();
+                    this._resizing = false;
+                    this._changeDetectorRef.markForCheck();
+                }, 100);
+            }
+        });
+    }
+    ngAfterContentInit() {
+        // Note: doesn't need to unsubscribe since `QueryList.changes`
+        // gets completed by Angular when the view is destroyed.
+        this._breadcrumbs.changes
+            .pipe(startWith(this._breadcrumbs))
+            .subscribe(() => {
+            this.setCrumbIcons();
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    /*
+     * Current width of the element container
+     */
+    get nativeElementWidth() {
+        const element = this._elementRef.nativeElement;
+        // Need to take into account border, margin and padding that might be around all the crumbs
+        const style = window.getComputedStyle(element);
+        const borderLeft = parseInt(style.borderLeft, 10);
+        const borderRight = parseInt(style.borderRight, 10);
+        const marginLeft = parseInt(style.marginLeft, 10);
+        const marginRight = parseInt(style.marginRight, 10);
+        const paddingLeft = parseInt(style.paddingLeft, 10);
+        const paddingRight = parseInt(style.paddingRight, 10);
+        return (element.getBoundingClientRect().width -
+            borderLeft -
+            borderRight -
+            marginLeft -
+            marginRight -
+            paddingLeft -
+            paddingRight);
+    }
+    /**
+     * The total count of individual breadcrumbs
+     */
+    get count() {
+        return this._breadcrumbs ? this._breadcrumbs.length : 0;
+    }
+    /**
+     * Set the crumb icon separators
+     */
+    setCrumbIcons() {
+        if (this._breadcrumbs) {
+            const breadcrumbArray = this._breadcrumbs.toArray();
+            breadcrumbArray.forEach((breadcrumb, index) => {
+                breadcrumb.separatorIcon = this.separatorIcon;
+                // don't show the icon on the last breadcrumb
+                breadcrumb.displayIcon = index < breadcrumbArray.length - 1;
+            });
+        }
+    }
+    _calculateVisibility() {
+        const crumbsArray = this._breadcrumbs.toArray();
+        let crumbWidthSum = 0;
+        const hiddenCrumbs = [];
+        // loop through crumbs in reverse order to calculate which ones should be removed
+        for (let i = crumbsArray.length - 1; i >= 0; i--) {
+            const breadcrumb = crumbsArray[i];
+            // if crumb exceeds width, then we skip it from the sum and add it into the hiddencrumbs array
+            // and hide it
+            if (crumbWidthSum + breadcrumb.width > this.nativeElementWidth) {
+                breadcrumb.displayCrumb = false;
+                hiddenCrumbs.push(breadcrumb);
+            }
+            else {
+                // else we show it
+                breadcrumb.displayCrumb = true;
+            }
+            crumbWidthSum += breadcrumb.width;
+        }
+        this.hiddenBreadcrumbs = hiddenCrumbs;
+        this._changeDetectorRef.markForCheck();
+    }
+}
+TdBreadcrumbsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBreadcrumbsComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TdBreadcrumbsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TdBreadcrumbsComponent, selector: "td-breadcrumbs", inputs: { separatorIcon: "separatorIcon" }, host: { properties: { "class.td-breadcrumbs": "this.tdBreadCrumbsClass" } }, queries: [{ propertyName: "_breadcrumbs", predicate: TdBreadcrumbComponent, descendants: true }], ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{display:flex;align-items:center}:host.td-breadcrumbs{white-space:nowrap}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TdBreadcrumbsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'td-breadcrumbs', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n", styles: [":host{display:flex;align-items:center}:host.td-breadcrumbs{white-space:nowrap}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { tdBreadCrumbsClass: [{
+                type: HostBinding,
+                args: ['class.td-breadcrumbs']
+            }], _breadcrumbs: [{
+                type: ContentChildren,
+                args: [TdBreadcrumbComponent, { descendants: true }]
+            }], separatorIcon: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumbs.component.js","sourceRoot":"","sources":["../../../../../libs/angular/breadcrumbs/src/breadcrumbs.component.ts","../../../../../libs/angular/breadcrumbs/src/breadcrumbs.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ContentChildren,\n  QueryList,\n  OnInit,\n  OnDestroy,\n  ChangeDetectionStrategy,\n  AfterContentInit,\n  ChangeDetectorRef,\n  ElementRef,\n  Input,\n  HostBinding,\n} from '@angular/core';\n\nimport { fromEvent, Subject } from 'rxjs';\nimport { debounceTime, startWith, takeUntil } from 'rxjs/operators';\n\nimport { TdBreadcrumbComponent } from './breadcrumb/breadcrumb.component';\n\n@Component({\n  selector: 'td-breadcrumbs',\n  styleUrls: ['./breadcrumbs.component.scss'],\n  templateUrl: './breadcrumbs.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TdBreadcrumbsComponent\n  implements OnInit, AfterContentInit, OnDestroy\n{\n  private _resizing = false;\n  private _separatorIcon = 'chevron_right';\n  private _destroy$ = new Subject<void>();\n\n  @HostBinding('class.td-breadcrumbs') tdBreadCrumbsClass = true;\n\n  // all the sub components, which are the individual breadcrumbs\n  @ContentChildren(TdBreadcrumbComponent, { descendants: true })\n  _breadcrumbs!: QueryList<TdBreadcrumbComponent>;\n  // the list of hidden breadcrumbs not shown right now (responsive)\n  hiddenBreadcrumbs: TdBreadcrumbComponent[] = [];\n\n  /**\n   * Sets the icon url shown between breadcrumbs. Defaults to 'chevron_right'.\n   */\n  @Input() public set separatorIcon(separatorIcon: string) {\n    this._separatorIcon = separatorIcon;\n    this.setCrumbIcons();\n  }\n  public get separatorIcon(): string {\n    return this._separatorIcon;\n  }\n\n  constructor(\n    private _elementRef: ElementRef,\n    private _changeDetectorRef: ChangeDetectorRef\n  ) {}\n\n  ngOnInit(): void {\n    fromEvent(window, 'resize')\n      .pipe(debounceTime(10), takeUntil(this._destroy$))\n      .subscribe(() => {\n        if (!this._resizing) {\n          this._resizing = true;\n          setTimeout(() => {\n            this._calculateVisibility();\n            this._resizing = false;\n            this._changeDetectorRef.markForCheck();\n          }, 100);\n        }\n      });\n  }\n\n  ngAfterContentInit(): void {\n    // Note: doesn't need to unsubscribe since `QueryList.changes`\n    // gets completed by Angular when the view is destroyed.\n    this._breadcrumbs.changes\n      .pipe(startWith(this._breadcrumbs))\n      .subscribe(() => {\n        this.setCrumbIcons();\n        this._changeDetectorRef.markForCheck();\n      });\n  }\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  /*\n   * Current width of the element container\n   */\n  get nativeElementWidth(): number {\n    const element: HTMLElement = <HTMLElement>this._elementRef.nativeElement;\n    // Need to take into account border, margin and padding that might be around all the crumbs\n    const style: CSSStyleDeclaration = window.getComputedStyle(element);\n    const borderLeft: number = parseInt(style.borderLeft, 10);\n    const borderRight: number = parseInt(style.borderRight, 10);\n    const marginLeft: number = parseInt(style.marginLeft, 10);\n    const marginRight: number = parseInt(style.marginRight, 10);\n    const paddingLeft: number = parseInt(style.paddingLeft, 10);\n    const paddingRight: number = parseInt(style.paddingRight, 10);\n\n    return (\n      element.getBoundingClientRect().width -\n      borderLeft -\n      borderRight -\n      marginLeft -\n      marginRight -\n      paddingLeft -\n      paddingRight\n    );\n  }\n\n  /**\n   * The total count of individual breadcrumbs\n   */\n  get count(): number {\n    return this._breadcrumbs ? this._breadcrumbs.length : 0;\n  }\n\n  /**\n   * Set the crumb icon separators\n   */\n  private setCrumbIcons(): void {\n    if (this._breadcrumbs) {\n      const breadcrumbArray: TdBreadcrumbComponent[] =\n        this._breadcrumbs.toArray();\n      breadcrumbArray.forEach(\n        (breadcrumb: TdBreadcrumbComponent, index: number) => {\n          breadcrumb.separatorIcon = this.separatorIcon;\n          // don't show the icon on the last breadcrumb\n          breadcrumb.displayIcon = index < breadcrumbArray.length - 1;\n        }\n      );\n    }\n  }\n\n  private _calculateVisibility(): void {\n    const crumbsArray: TdBreadcrumbComponent[] = this._breadcrumbs.toArray();\n    let crumbWidthSum = 0;\n    const hiddenCrumbs: TdBreadcrumbComponent[] = [];\n    // loop through crumbs in reverse order to calculate which ones should be removed\n    for (let i: number = crumbsArray.length - 1; i >= 0; i--) {\n      const breadcrumb: TdBreadcrumbComponent = crumbsArray[i];\n\n      // if crumb exceeds width, then we skip it from the sum and add it into the hiddencrumbs array\n      // and hide it\n      if (crumbWidthSum + breadcrumb.width > this.nativeElementWidth) {\n        breadcrumb.displayCrumb = false;\n        hiddenCrumbs.push(breadcrumb);\n      } else {\n        // else we show it\n        breadcrumb.displayCrumb = true;\n      }\n      crumbWidthSum += breadcrumb.width;\n    }\n\n    this.hiddenBreadcrumbs = hiddenCrumbs;\n    this._changeDetectorRef.markForCheck();\n  }\n}\n","<ng-content></ng-content>\n"]}

package/{esm2022 → esm2020}/breadcrumbs/breadcrumbs.module.mjs

@@ -5,11 +5,11 @@ import { TdBreadcrumbsComponent } from './breadcrumbs.component';
 import { TdBreadcrumbComponent } from './breadcrumb/breadcrumb.component';
 import * as i0 from "@angular/core";
 export class CovalentBreadcrumbsModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBreadcrumbsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: CovalentBreadcrumbsModule, declarations: [TdBreadcrumbsComponent, TdBreadcrumbComponent], imports: [CommonModule, MatIconModule], exports: [TdBreadcrumbsComponent, TdBreadcrumbComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBreadcrumbsModule, imports: [CommonModule, MatIconModule] });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: CovalentBreadcrumbsModule, decorators: [{
+CovalentBreadcrumbsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBreadcrumbsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentBreadcrumbsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CovalentBreadcrumbsModule, declarations: [TdBreadcrumbsComponent, TdBreadcrumbComponent], imports: [CommonModule, MatIconModule], exports: [TdBreadcrumbsComponent, TdBreadcrumbComponent] });
+CovalentBreadcrumbsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBreadcrumbsModule, imports: [CommonModule, MatIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CovalentBreadcrumbsModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule, MatIconModule],
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImpor
                     exports: [TdBreadcrumbsComponent, TdBreadcrumbComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYnMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2JyZWFkY3J1bWJzL3NyYy9icmVhZGNydW1icy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDOztBQU8xRSxNQUFNLE9BQU8seUJBQXlCO3VHQUF6Qix5QkFBeUI7d0dBQXpCLHlCQUF5QixpQkFIckIsc0JBQXNCLEVBQUUscUJBQXFCLGFBRGxELFlBQVksRUFBRSxhQUFhLGFBRTNCLHNCQUFzQixFQUFFLHFCQUFxQjt3R0FFNUMseUJBQXlCLFlBSjFCLFlBQVksRUFBRSxhQUFhOzsyRkFJMUIseUJBQXlCO2tCQUxyQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7b0JBQ3RDLFlBQVksRUFBRSxDQUFDLHNCQUFzQixFQUFFLHFCQUFxQixDQUFDO29CQUM3RCxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxxQkFBcUIsQ0FBQztpQkFDekQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcblxuaW1wb3J0IHsgVGRCcmVhZGNydW1ic0NvbXBvbmVudCB9IGZyb20gJy4vYnJlYWRjcnVtYnMuY29tcG9uZW50JztcbmltcG9ydCB7IFRkQnJlYWRjcnVtYkNvbXBvbmVudCB9IGZyb20gJy4vYnJlYWRjcnVtYi9icmVhZGNydW1iLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIE1hdEljb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtUZEJyZWFkY3J1bWJzQ29tcG9uZW50LCBUZEJyZWFkY3J1bWJDb21wb25lbnRdLFxuICBleHBvcnRzOiBbVGRCcmVhZGNydW1ic0NvbXBvbmVudCwgVGRCcmVhZGNydW1iQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQ292YWxlbnRCcmVhZGNydW1ic01vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYnMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2JyZWFkY3J1bWJzL3NyYy9icmVhZGNydW1icy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDOztBQU8xRSxNQUFNLE9BQU8seUJBQXlCOzt1SEFBekIseUJBQXlCO3dIQUF6Qix5QkFBeUIsaUJBSHJCLHNCQUFzQixFQUFFLHFCQUFxQixhQURsRCxZQUFZLEVBQUUsYUFBYSxhQUUzQixzQkFBc0IsRUFBRSxxQkFBcUI7d0hBRTVDLHlCQUF5QixZQUoxQixZQUFZLEVBQUUsYUFBYTs0RkFJMUIseUJBQXlCO2tCQUxyQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7b0JBQ3RDLFlBQVksRUFBRSxDQUFDLHNCQUFzQixFQUFFLHFCQUFxQixDQUFDO29CQUM3RCxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxxQkFBcUIsQ0FBQztpQkFDekQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcblxuaW1wb3J0IHsgVGRCcmVhZGNydW1ic0NvbXBvbmVudCB9IGZyb20gJy4vYnJlYWRjcnVtYnMuY29tcG9uZW50JztcbmltcG9ydCB7IFRkQnJlYWRjcnVtYkNvbXBvbmVudCB9IGZyb20gJy4vYnJlYWRjcnVtYi9icmVhZGNydW1iLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIE1hdEljb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtUZEJyZWFkY3J1bWJzQ29tcG9uZW50LCBUZEJyZWFkY3J1bWJDb21wb25lbnRdLFxuICBleHBvcnRzOiBbVGRCcmVhZGNydW1ic0NvbXBvbmVudCwgVGRCcmVhZGNydW1iQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQ292YWxlbnRCcmVhZGNydW1ic01vZHVsZSB7fVxuIl19

package/esm2020/common/behaviors/control-value-accesor.mixin.mjs

@@ -0,0 +1,41 @@
+import { Subject } from 'rxjs';
+const noop = () => {
+    // empty method
+};
+/** Mixin to augment a component with ngModel support. */
+export function mixinControlValueAccessor(base, initialValue) {
+    return class extends base {
+        constructor(...args) {
+            super(...args);
+            this._value = initialValue instanceof Array
+                ? Object.assign([], initialValue)
+                : initialValue;
+            this.onChange = (_) => noop;
+            this.onTouched = () => noop;
+            this._subjectValueChanges = new Subject();
+            this.valueChanges = this._subjectValueChanges.asObservable();
+        }
+        set value(v) {
+            if (v !== this._value) {
+                this._value = v;
+                this.onChange(v);
+                this._changeDetectorRef.markForCheck();
+                this._subjectValueChanges.next(v);
+            }
+        }
+        get value() {
+            return this._value;
+        }
+        writeValue(value) {
+            this.value = value;
+            this._changeDetectorRef.markForCheck();
+        }
+        registerOnChange(fn) {
+            this.onChange = fn;
+        }
+        registerOnTouched(fn) {
+            this.onTouched = fn;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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