@covalent/core 4.0.0 → 4.1.0-develop.10

package/dynamic-menu/package.json

@@ -1,11 +1,10 @@
 {
-  "main": "../bundles/covalent-core-dynamic-menu.umd.js",
-  "module": "../fesm2015/covalent-core-dynamic-menu.js",
-  "es2015": "../fesm2015/covalent-core-dynamic-menu.js",
-  "esm2015": "../esm2015/dynamic-menu/covalent-core-dynamic-menu.js",
-  "fesm2015": "../fesm2015/covalent-core-dynamic-menu.js",
+  "module": "../fesm2015/covalent-core-dynamic-menu.mjs",
+  "es2020": "../fesm2020/covalent-core-dynamic-menu.mjs",
+  "esm2020": "../esm2020/dynamic-menu/covalent-core-dynamic-menu.mjs",
+  "fesm2020": "../fesm2020/covalent-core-dynamic-menu.mjs",
+  "fesm2015": "../fesm2015/covalent-core-dynamic-menu.mjs",
   "typings": "covalent-core-dynamic-menu.d.ts",
-  "metadata": "covalent-core-dynamic-menu.metadata.json",
   "sideEffects": false,
   "name": "@covalent/core/dynamic-menu"
-}
+}

package/dynamic-menu/public_api.d.ts

@@ -1,3 +1,5 @@
 export * from './dynamic-menu.module';
+export * from './dynamic-menu.menu';
 export * from './dynamic-menu.component';
 export * from './dynamic-menu-item/dynamic-menu-item.component';
+export * from './dynamic-menu-item/dynamic-menu-link/dynamic-menu-link.component';

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/material/icon";
+import * as i2 from "@angular/common";
+export class TdBreadcrumbComponent {
+    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;
+    }
+    // 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';
+    }
+    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: "13.2.2", ngImport: i0, type: TdBreadcrumbComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TdBreadcrumbComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: TdBreadcrumbComponent, selector: "td-breadcrumb, a[td-breadcrumb]", host: { properties: { "class.mat-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"], components: [{ type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", 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.mat-button']
+            }], tdBreadCrumbClass: [{
+                type: HostBinding,
+                args: ['class.td-breadcrumb']
+            }], displayBinding: [{
+                type: HostBinding,
+                args: ['style.display']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/breadcrumbs/breadcrumbs.component.mjs

@@ -0,0 +1,130 @@
+import { Component, ContentChildren, QueryList, ChangeDetectionStrategy, ChangeDetectorRef, ElementRef, Input, HostBinding, } from '@angular/core';
+import { Subscription, fromEvent } from 'rxjs';
+import { debounceTime, startWith } from 'rxjs/operators';
+import { TdBreadcrumbComponent } from './breadcrumb/breadcrumb.component';
+import * as i0 from "@angular/core";
+export class TdBreadcrumbsComponent {
+    constructor(_elementRef, _changeDetectorRef) {
+        this._elementRef = _elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._resizeSubscription = Subscription.EMPTY;
+        this._resizing = false;
+        this._separatorIcon = 'chevron_right';
+        this.tdBreadCrumbsClass = true;
+        // the list of hidden breadcrumbs not shown right now (responsive)
+        this.hiddenBreadcrumbs = [];
+    }
+    /**
+     * Sets the icon url shown between breadcrumbs. Defaults to 'chevron_right'.
+     */
+    set separatorIcon(separatorIcon) {
+        this._separatorIcon = separatorIcon;
+        this.setCrumbIcons();
+    }
+    get separatorIcon() {
+        return this._separatorIcon;
+    }
+    ngOnInit() {
+        this._resizeSubscription = fromEvent(window, 'resize')
+            .pipe(debounceTime(10))
+            .subscribe(() => {
+            if (!this._resizing) {
+                this._resizing = true;
+                setTimeout(() => {
+                    this._calculateVisibility();
+                    this._resizing = false;
+                    this._changeDetectorRef.markForCheck();
+                }, 100);
+            }
+        });
+    }
+    ngAfterContentInit() {
+        this._contentChildrenSub = this._breadcrumbs.changes
+            .pipe(startWith(this._breadcrumbs))
+            .subscribe(() => {
+            this.setCrumbIcons();
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        this._resizeSubscription.unsubscribe();
+        this._contentChildrenSub.unsubscribe();
+    }
+    /*
+     * 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: "13.2.2", ngImport: i0, type: TdBreadcrumbsComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TdBreadcrumbsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", 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: "13.2.2", 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 { Subscription, fromEvent } from 'rxjs';\nimport { debounceTime, startWith } 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 _resizeSubscription: Subscription = Subscription.EMPTY;\n  private _contentChildrenSub!: Subscription;\n  private _resizing = false;\n  private _separatorIcon = 'chevron_right';\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    this._resizeSubscription = fromEvent(window, 'resize')\n      .pipe(debounceTime(10))\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    this._contentChildrenSub = 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._resizeSubscription.unsubscribe();\n    this._contentChildrenSub.unsubscribe();\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/esm2020/breadcrumbs/breadcrumbs.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatIconModule } from '@angular/material/icon';
+import { TdBreadcrumbsComponent } from './breadcrumbs.component';
+import { TdBreadcrumbComponent } from './breadcrumb/breadcrumb.component';
+import * as i0 from "@angular/core";
+export class CovalentBreadcrumbsModule {
+}
+CovalentBreadcrumbsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBreadcrumbsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentBreadcrumbsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBreadcrumbsModule, declarations: [TdBreadcrumbsComponent, TdBreadcrumbComponent], imports: [CommonModule, MatIconModule], exports: [TdBreadcrumbsComponent, TdBreadcrumbComponent] });
+CovalentBreadcrumbsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBreadcrumbsModule, imports: [[CommonModule, MatIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentBreadcrumbsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, MatIconModule],
+                    declarations: [TdBreadcrumbsComponent, TdBreadcrumbComponent],
+                    exports: [TdBreadcrumbsComponent, TdBreadcrumbComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYnMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2JyZWFkY3J1bWJzL3NyYy9icmVhZGNydW1icy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDOztBQU8xRSxNQUFNLE9BQU8seUJBQXlCOztzSEFBekIseUJBQXlCO3VIQUF6Qix5QkFBeUIsaUJBSHJCLHNCQUFzQixFQUFFLHFCQUFxQixhQURsRCxZQUFZLEVBQUUsYUFBYSxhQUUzQixzQkFBc0IsRUFBRSxxQkFBcUI7dUhBRTVDLHlCQUF5QixZQUozQixDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7MkZBSTNCLHlCQUF5QjtrQkFMckMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDO29CQUN0QyxZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxxQkFBcUIsQ0FBQztvQkFDN0QsT0FBTyxFQUFFLENBQUMsc0JBQXNCLEVBQUUscUJBQXFCLENBQUM7aUJBQ3pEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XG5cbmltcG9ydCB7IFRkQnJlYWRjcnVtYnNDb21wb25lbnQgfSBmcm9tICcuL2JyZWFkY3J1bWJzLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBUZEJyZWFkY3J1bWJDb21wb25lbnQgfSBmcm9tICcuL2JyZWFkY3J1bWIvYnJlYWRjcnVtYi5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBNYXRJY29uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbVGRCcmVhZGNydW1ic0NvbXBvbmVudCwgVGRCcmVhZGNydW1iQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW1RkQnJlYWRjcnVtYnNDb21wb25lbnQsIFRkQnJlYWRjcnVtYkNvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIENvdmFsZW50QnJlYWRjcnVtYnNNb2R1bGUge31cbiJdfQ==

package/esm2020/breadcrumbs/covalent-core-breadcrumbs.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtY29yZS1icmVhZGNydW1icy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9icmVhZGNydW1icy9zcmMvY292YWxlbnQtY29yZS1icmVhZGNydW1icy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/breadcrumbs/public_api.mjs

@@ -0,0 +1,4 @@
+export * from './breadcrumbs.module';
+export * from './breadcrumbs.component';
+export * from './breadcrumb/breadcrumb.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9icmVhZGNydW1icy9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnJlYWRjcnVtYnMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vYnJlYWRjcnVtYnMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYnJlYWRjcnVtYi9icmVhZGNydW1iLmNvbXBvbmVudCc7XG4iXX0=

package/esm2020/common/animations/bounce/bounce.animation.mjs

@@ -0,0 +1,70 @@
+import { trigger, state, style, keyframes, transition, animate, query, animateChild, group, } from '@angular/animations';
+/**
+ * const tdBounceAnimation
+ *
+ * Parameter Options:
+ * * duration: Duration the animation will run in milliseconds. Defaults to 500 ms.
+ * * delay: Delay before the animation will run in milliseconds. Defaults to 0 ms.
+ * * ease: Animation accelerate and decelerate style. Defaults to ease-out.
+ *
+ * Returns an [AnimationTriggerMetadata] object with boolean states for a bounce animation.
+ *
+ * usage: [@tdBounce]="{ value: true | false, params: { duration: 200 }}"
+ */
+export const tdBounceAnimation = trigger('tdBounce', [
+    state('0', style({
+        transform: 'translate3d(0, 0, 0)',
+    })),
+    state('1', style({
+        transform: 'translate3d(0, 0, 0)',
+    })),
+    transition('0 <=> 1', [
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ ease }}', keyframes([
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+                    transform: 'translate3d(0, 0, 0)',
+                    offset: 0,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+                    transform: 'translate3d(0, 0, 0)',
+                    offset: 0.2,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.755, 0.050, 0.855, 0.060)',
+                    transform: 'translate3d(0, -30px, 0)',
+                    offset: 0.4,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.755, 0.050, 0.855, 0.060)',
+                    transform: 'translate3d(0, -30px, 0)',
+                    offset: 0.43,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+                    transform: 'translate3d(0, 0, 0)',
+                    offset: 0.53,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.755, 0.050, 0.855, 0.060)',
+                    transform: 'translate3d(0, -15px, 0)',
+                    offset: 0.7,
+                }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+                    transform: 'translate3d(0, 0, 0)',
+                    offset: 0.8,
+                }),
+                style({ transform: 'translate3d(0, -4px, 0)', offset: 0.9 }),
+                style({
+                    animationTimingFunction: 'cubic-bezier(0.215, 0.610, 0.355, 1.000)',
+                    transform: 'translate3d(0, 0, 0)',
+                    offset: 1.0,
+                }),
+            ])),
+        ]),
+    ], { params: { duration: 500, delay: '0', ease: 'ease-out' } }),
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/animations/collapse/collapse.animation.mjs

@@ -0,0 +1,51 @@
+import { trigger, state, style, transition, animate, AUTO_STYLE, query, animateChild, group, } from '@angular/animations';
+/**
+ * const tdCollapseAnimation
+ *
+ * Parameter Options:
+ * * duration: Duration the animation will run in milliseconds. Defaults to 150 ms.
+ * * delay: Delay before the animation will run in milliseconds. Defaults to 0 ms.
+ * * easeOnClose: Animation accelerates and decelerates when closing. Defaults to ease-in.
+ * * easeOnOpen: Animation accelerates and decelerates when opening. Defaults to ease-out.
+ *
+ * Returns an [AnimationTriggerMetadata] object with boolean states for a collapse/expand animation.
+ *
+ * usage: [@tdCollapse]="{ value: true | false, params: { duration: 500 }}"
+ */
+export const tdCollapseAnimation = trigger('tdCollapse', [
+    state('1', style({
+        height: '0',
+        overflow: 'hidden',
+    })),
+    state('0', style({
+        height: AUTO_STYLE,
+        overflow: AUTO_STYLE,
+    })),
+    transition('0 => 1', [
+        style({
+            overflow: 'hidden',
+            height: AUTO_STYLE,
+        }),
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ ease }}', style({
+                height: '0',
+                overflow: 'hidden',
+            })),
+        ]),
+    ], { params: { duration: 150, delay: '0', ease: 'ease-in' } }),
+    transition('1 => 0', [
+        style({
+            height: '0',
+            overflow: 'hidden',
+        }),
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ ease }}', style({
+                overflow: 'hidden',
+                height: AUTO_STYLE,
+            })),
+        ]),
+    ], { params: { duration: 150, delay: '0', ease: 'ease-out' } }),
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/animations/common/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21tb24vc3JjL2FuaW1hdGlvbnMvY29tbW9uL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUFuaW1hdGlvbk9wdGlvbnMge1xuICBhbmNob3I/OiBzdHJpbmc7XG4gIGR1cmF0aW9uPzogbnVtYmVyO1xuICBkZWxheT86IG51bWJlcjtcbn1cbiJdfQ==

package/esm2020/common/animations/fade/fadeInOut.animation.mjs

@@ -0,0 +1,37 @@
+import { trigger, state, style, transition, animate, AUTO_STYLE, query, animateChild, group, } from '@angular/animations';
+/**
+ * const tdFadeInOutAnimation
+ *
+ * Parameter Options:
+ * * duration: Duration the animation will run in milliseconds. Defaults to 150 ms.
+ * * delay: Delay before the animation will run in milliseconds. Defaults to 0 ms.
+ * * easeOnIn: Animation accelerates and decelerates when fading in. Defaults to ease-in.
+ * * easeOnOut: Animation accelerates and decelerates when fading out. Defaults to ease-out.
+ *
+ * Returns an [AnimationTriggerMetadata] object with boolean states for a fade animation.
+ *
+ * usage: [@tdFadeInOut]="{ value: true | false, params: { duration: 200 }}"
+ */
+export const tdFadeInOutAnimation = trigger('tdFadeInOut', [
+    state('0', style({
+        opacity: '0',
+        visibility: 'hidden',
+    })),
+    state('1', style({
+        opacity: AUTO_STYLE,
+        visibility: AUTO_STYLE,
+    })),
+    transition('0 => 1', [
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ easeOnIn }}'),
+        ]),
+    ], { params: { duration: 150, delay: '0', easeOnIn: 'ease-in' } }),
+    transition('1 => 0', [
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ easeOnOut }}'),
+        ]),
+    ], { params: { duration: 150, delay: '0', easeOnOut: 'ease-out' } }),
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/animations/flash/flash.animation.mjs

@@ -0,0 +1,34 @@
+import { trigger, state, style, keyframes, transition, animate, query, animateChild, group, } from '@angular/animations';
+/**
+ * const tdFlashAnimation
+ *
+ * Parameter Options:
+ * * duration: Duration the animation will run in milliseconds. Defaults to 500 ms.
+ * * delay: Delay before the animation will run in milliseconds. Defaults to 0 ms.
+ * * ease: Animation accelerate and decelerate style. Defaults to ease-out.
+ *
+ * Returns an [AnimationTriggerMetadata] object with boolean states for a flash animation.
+ *
+ * usage: [@tdFlash]="{ value: true | false, params: { duration: 200 }}"
+ */
+export const tdFlashAnimation = trigger('tdFlash', [
+    state('0', style({
+        opacity: 1,
+    })),
+    state('1', style({
+        opacity: 1,
+    })),
+    transition('0 <=> 1', [
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ ease }}', keyframes([
+                style({ opacity: 1, offset: 0 }),
+                style({ opacity: 0, offset: 0.25 }),
+                style({ opacity: 1, offset: 0.5 }),
+                style({ opacity: 0, offset: 0.75 }),
+                style({ opacity: 1, offset: 1.0 }),
+            ])),
+        ]),
+    ], { params: { duration: 500, delay: '0', ease: 'ease-out' } }),
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/animations/headshake/headshake.animation.mjs

@@ -0,0 +1,47 @@
+import { trigger, state, style, keyframes, transition, animate, query, animateChild, group, } from '@angular/animations';
+/**
+ * const tdHeadshakeAnimation
+ *
+ * Parameter Options:
+ * * duration: Duration the animation will run in milliseconds. Defaults to 500 ms.
+ * * delay: Delay before the animation will run in milliseconds. Defaults to 0 ms.
+ * * ease: Animation accelerate and decelerate style. Defaults to ease-out.
+ *
+ * Returns an [AnimationTriggerMetadata] object with boolean states for a headshake animation.
+ *
+ * usage: [@tdHeadshake]="{ value: true | false, params: { duration: 200 }}"
+ */
+export const tdHeadshakeAnimation = trigger('tdHeadshake', [
+    state('0', style({
+        transform: 'translateX(0)',
+    })),
+    state('1', style({
+        transform: 'translateX(0)',
+    })),
+    transition('0 <=> 1', [
+        group([
+            query('@*', animateChild(), { optional: true }),
+            animate('{{ duration }}ms {{ delay }}ms {{ ease }}', keyframes([
+                style({ transform: 'translateX(0)', offset: 0 }),
+                style({
+                    transform: 'translateX(-6px) rotateY(-9deg)',
+                    offset: 0.065,
+                }),
+                style({
+                    transform: 'translateX(5px) rotateY(7deg)',
+                    offset: 0.185,
+                }),
+                style({
+                    transform: 'translateX(-3px) rotateY(-5deg)',
+                    offset: 0.315,
+                }),
+                style({
+                    transform: 'translateX(2px) rotateY(3deg)',
+                    offset: 0.435,
+                }),
+                style({ transform: 'translateX(0)', offset: 0.5 }),
+            ])),
+        ]),
+    ], { params: { duration: 500, delay: '0', ease: 'ease-out' } }),
+]);
+//# sourceMappingURL=data:application/json;base64,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