@covalent/core 3.1.2 → 4.0.0-beta.2

package/esm2020/common/forms/auto-trim/auto-trim.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive } from '@angular/core';
+import { HostListener, Host, Optional } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class TdAutoTrimDirective {
+    constructor(_model) {
+        this._model = _model;
+    }
+    /**
+     * Listens to host's (blur) event and trims value.
+     */
+    onBlur(event) {
+        if (this._model && this._model.value && typeof this._model.value === 'string') {
+            this._model.update.emit(this._model.value.trim());
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdAutoTrimDirective.ɵfac = function TdAutoTrimDirective_Factory(t) { return new (t || TdAutoTrimDirective)(i0.ɵɵdirectiveInject(i1.NgModel, 9)); };
+/** @nocollapse */ /** @nocollapse */ TdAutoTrimDirective.ɵdir = /** @pureOrBreakMyCode */ i0.ɵɵdefineDirective({ type: TdAutoTrimDirective, selectors: [["", "tdAutoTrim", ""]], hostBindings: function TdAutoTrimDirective_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("blur", function TdAutoTrimDirective_blur_HostBindingHandler($event) { return ctx.onBlur($event); });
+    } } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdAutoTrimDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[tdAutoTrim]',
+            }]
+    }], function () { return [{ type: i1.NgModel, decorators: [{
+                type: Optional
+            }, {
+                type: Host
+            }] }]; }, { onBlur: [{
+            type: HostListener,
+            args: ['blur', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by10cmltLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9jb3JlL2NvbW1vbi9mb3Jtcy9hdXRvLXRyaW0vYXV0by10cmltLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM3RCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7OztBQUt6QyxNQUFNLE9BQU8sbUJBQW1CO0lBQzlCLFlBQXdDLE1BQWU7UUFBZixXQUFNLEdBQU4sTUFBTSxDQUFTO0lBQUcsQ0FBQztJQUUzRDs7T0FFRztJQUVILE1BQU0sQ0FBQyxLQUFZO1FBQ2pCLElBQUksSUFBSSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssSUFBSSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxLQUFLLFFBQVEsRUFBRTtZQUM3RSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztTQUNuRDtJQUNILENBQUM7OzRIQVhVLG1CQUFtQjt3SEFBbkIsbUJBQW1CO29HQUFuQixrQkFBYzs7dUZBQWQsbUJBQW1CO2NBSC9CLFNBQVM7ZUFBQztnQkFDVCxRQUFRLEVBQUUsY0FBYzthQUN6Qjs7c0JBRWMsUUFBUTs7c0JBQUksSUFBSTt3QkFNN0IsTUFBTTtrQkFETCxZQUFZO21CQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSG9zdExpc3RlbmVyLCBIb3N0LCBPcHRpb25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTmdNb2RlbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3RkQXV0b1RyaW1dJyxcbn0pXG5leHBvcnQgY2xhc3MgVGRBdXRvVHJpbURpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKEBPcHRpb25hbCgpIEBIb3N0KCkgcHJpdmF0ZSBfbW9kZWw6IE5nTW9kZWwpIHt9XG5cbiAgLyoqXG4gICAqIExpc3RlbnMgdG8gaG9zdCdzIChibHVyKSBldmVudCBhbmQgdHJpbXMgdmFsdWUuXG4gICAqL1xuICBASG9zdExpc3RlbmVyKCdibHVyJywgWyckZXZlbnQnXSlcbiAgb25CbHVyKGV2ZW50OiBFdmVudCk6IHZvaWQge1xuICAgIGlmICh0aGlzLl9tb2RlbCAmJiB0aGlzLl9tb2RlbC52YWx1ZSAmJiB0eXBlb2YgdGhpcy5fbW9kZWwudmFsdWUgPT09ICdzdHJpbmcnKSB7XG4gICAgICB0aGlzLl9tb2RlbC51cGRhdGUuZW1pdCh0aGlzLl9tb2RlbC52YWx1ZS50cmltKCkpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2020/common/forms/validators/validators.mjs

@@ -0,0 +1,29 @@
+import { Validators } from '@angular/forms';
+export class CovalentValidators {
+    static min(minValue) {
+        // tslint:disable-next-line:prefer-immediate-return
+        const func = (c) => {
+            if (!!Validators.required(c) || (!minValue && minValue !== 0)) {
+                return undefined;
+            }
+            const v = c.value;
+            return v < minValue ? { min: { minValue, actualValue: v } } : undefined;
+        };
+        return func;
+    }
+    static max(maxValue) {
+        // tslint:disable-next-line:prefer-immediate-return
+        const func = (c) => {
+            if (!!Validators.required(c) || (!maxValue && maxValue !== 0)) {
+                return undefined;
+            }
+            const v = c.value;
+            return v > maxValue ? { max: { maxValue, actualValue: v } } : undefined;
+        };
+        return func;
+    }
+    static numberRequired(c) {
+        return Number.isNaN(c.value) ? { required: true } : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/common/functions/clipboard.js → esm2020/common/functions/clipboard.mjs}

@@ -1,30 +1,23 @@
-/**
- * @fileoverview added by tsickle
- * Generated from: functions/clipboard.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Assign a text value to the system clipboard. Note: Due to browser
  * security restrictions, the copy will only succeed if this method
  * is invoked as a result of a user action (eg. user button click).
  *
- * @param {?} value text value to be assigned to clipboard.
- * @return {?} boolean indicating success/failure of copy operation.
+ * @param value text value to be assigned to clipboard.
+ * @returns boolean indicating success/failure of copy operation.
  */
 export function copyToClipboard(value) {
     // Create a temporary textarea element and append to DOM
-    /** @type {?} */
     const fakeTextArea = document.createElement('textarea');
     document.body.appendChild(fakeTextArea);
     // Assign value to be copied to clipboard
     fakeTextArea.value = value;
     fakeTextArea.select();
     // Copy to clipboard
-    /** @type {?} */
     const success = document.execCommand('copy');
     // Remove temporary textarea
     document.body.removeChild(fakeTextArea);
     // Return boolean indicating if exec command succeeded
     return success;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpcGJvYXJkLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9jb3JlL2NvbW1vbi8iLCJzb3VyY2VzIjpbImZ1bmN0aW9ucy9jbGlwYm9hcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQVFBLE1BQU0sVUFBVSxlQUFlLENBQUMsS0FBYTs7O1VBRXJDLFlBQVksR0FBd0IsUUFBUSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUM7SUFDNUUsUUFBUSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLENBQUM7SUFFeEMseUNBQXlDO0lBQ3pDLFlBQVksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQzNCLFlBQVksQ0FBQyxNQUFNLEVBQUUsQ0FBQzs7O1VBR2hCLE9BQU8sR0FBWSxRQUFRLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQztJQUVyRCw0QkFBNEI7SUFDNUIsUUFBUSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsWUFBWSxDQUFDLENBQUM7SUFFeEMsc0RBQXNEO0lBQ3RELE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEFzc2lnbiBhIHRleHQgdmFsdWUgdG8gdGhlIHN5c3RlbSBjbGlwYm9hcmQuIE5vdGU6IER1ZSB0byBicm93c2VyXG4gKiBzZWN1cml0eSByZXN0cmljdGlvbnMsIHRoZSBjb3B5IHdpbGwgb25seSBzdWNjZWVkIGlmIHRoaXMgbWV0aG9kXG4gKiBpcyBpbnZva2VkIGFzIGEgcmVzdWx0IG9mIGEgdXNlciBhY3Rpb24gKGVnLiB1c2VyIGJ1dHRvbiBjbGljaykuXG4gKlxuICogQHBhcmFtIHZhbHVlIHRleHQgdmFsdWUgdG8gYmUgYXNzaWduZWQgdG8gY2xpcGJvYXJkLlxuICogQHJldHVybnMgYm9vbGVhbiBpbmRpY2F0aW5nIHN1Y2Nlc3MvZmFpbHVyZSBvZiBjb3B5IG9wZXJhdGlvbi5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvcHlUb0NsaXBib2FyZCh2YWx1ZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gIC8vIENyZWF0ZSBhIHRlbXBvcmFyeSB0ZXh0YXJlYSBlbGVtZW50IGFuZCBhcHBlbmQgdG8gRE9NXG4gIGNvbnN0IGZha2VUZXh0QXJlYTogSFRNTFRleHRBcmVhRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3RleHRhcmVhJyk7XG4gIGRvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoZmFrZVRleHRBcmVhKTtcblxuICAvLyBBc3NpZ24gdmFsdWUgdG8gYmUgY29waWVkIHRvIGNsaXBib2FyZFxuICBmYWtlVGV4dEFyZWEudmFsdWUgPSB2YWx1ZTtcbiAgZmFrZVRleHRBcmVhLnNlbGVjdCgpO1xuXG4gIC8vIENvcHkgdG8gY2xpcGJvYXJkXG4gIGNvbnN0IHN1Y2Nlc3M6IGJvb2xlYW4gPSBkb2N1bWVudC5leGVjQ29tbWFuZCgnY29weScpO1xuXG4gIC8vIFJlbW92ZSB0ZW1wb3JhcnkgdGV4dGFyZWFcbiAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChmYWtlVGV4dEFyZWEpO1xuXG4gIC8vIFJldHVybiBib29sZWFuIGluZGljYXRpbmcgaWYgZXhlYyBjb21tYW5kIHN1Y2NlZWRlZFxuICByZXR1cm4gc3VjY2Vzcztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/functions/convert.mjs

@@ -0,0 +1,84 @@
+/**
+ * Conversion function that takes an array of objects and converts
+ * them to CSV format. Custom key and line separators can be specified.
+ *
+ * @param objects list of strings in JSON format or actual objects
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ * @returns CSV formatted string
+ */
+export function convertObjectsToCSV(objects, keySeparator = ',', lineSeparator = '\r\n') {
+    if (!objects) {
+        return '';
+    }
+    let outputString = '';
+    // Iterate through array, creating one output line per object
+    objects.forEach((value, key) => {
+        let line = '';
+        for (const index of Object.keys(objects[key])) {
+            if (line !== '') {
+                line += keySeparator;
+            }
+            if (objects[key][index] === null || objects[key][index] === undefined) {
+                objects[key][index] = '';
+            }
+            line += objects[key][index];
+        }
+        outputString += `${line}${lineSeparator}`;
+    });
+    // Append header row identifying keys into output
+    if (objects[0]) {
+        const headers = Object.keys(objects[0]).join(keySeparator);
+        outputString = `${headers}${lineSeparator}${outputString}`;
+    }
+    return outputString;
+}
+/**
+ * Conversion function that takes a CSV representation
+ * of objects and converts them to JSON.
+ * The first row in the input must be the object keys.
+ * Custom key separator and line separator can be specified.
+ * Indentation size for output JSON can be specified.
+ *
+ * @param csv list of strings in JSON format or actual objects
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2.
+ * @returns JSON formatted string
+ */
+export function convertCSVToJSON(csv, keySeparator = ',', lineSeparator = '\r\n', indent = 2) {
+    if (!csv) {
+        return '';
+    }
+    const csvArray = csv.split(lineSeparator);
+    // Input CSV must have a minimum of two rows
+    if (csvArray.length < 2) {
+        return '';
+    }
+    const newObjects = [];
+    // Extract object keys from header row
+    const keys = csvArray[0].split(keySeparator);
+    // Iterate through array, creating one output line per object
+    for (let i = 1; i < csvArray.length; i++) {
+        const newObject = {};
+        const values = csvArray[i].split(keySeparator);
+        if (values.length !== keys.length) {
+            continue;
+        }
+        for (let j = 0; j < keys.length; j++) {
+            newObject[keys[j]] = values[j];
+        }
+        newObjects.push(newObject);
+    }
+    return formatJSON(newObjects, indent);
+}
+/**
+ * Convert object to JSON using stringify. Indentation size for output JSON can be specified.
+ *
+ * @param json object to be converted
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2.
+ */
+export function formatJSON(json, indent = 2) {
+    return JSON.stringify(json, undefined, indent);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/functions/download.mjs

@@ -0,0 +1,75 @@
+import { convertObjectsToCSV, formatJSON } from './convert';
+/**
+ * Download CSV content to the specified file with .csv extension
+ * appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param csv CSV contents
+ */
+export function downloadCSV(fileBaseName, csv) {
+    downloadFile(`${fileBaseName}.csv`, csv, 'text/csv');
+}
+/**
+ * Download JSON content to the specified file with .json extension
+ * appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param json JSON contents
+ * @param format indicates if JSON should be prettied
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2
+ */
+export function downloadJSON(fileBaseName, json, format = false, indent = 2) {
+    downloadFile(`${fileBaseName}.json`, format ? formatJSON(JSON.parse(json), indent) : json, 'application/json');
+}
+/**
+ * Convert objects to CSV format and download to file with .csv
+ * extension appended to the provided base file name. Custom key
+ * separator and line separator can be specified.
+ *
+ * @param fileBaseName base name of destination file
+ * @param objects object array to be converted to CSV format
+ *   prior to writing to download destination
+ * @param keySeparator optional parameter to specify custom value separator
+ * @param lineSeparator optional parameter to specify custom end of line separator
+ */
+export function downloadObjectsToCSV(fileBaseName, objects, keySeparator = ',', lineSeparator = '\r\n') {
+    downloadFile(`${fileBaseName}.csv`, convertObjectsToCSV(objects, keySeparator, lineSeparator), 'text/csv');
+}
+/**
+ * Convert objects to JSON format and download to file with .json
+ * extension appended to the provided base file name.
+ *
+ * @param fileBaseName base name of destination file
+ * @param objects object array to be converted to JSON format
+ *   prior to writing to download destination
+ * @param indent optional parameter indicating space indentation for pretty output. Default is 2
+ */
+export function downloadObjectsToJSON(fileBaseName, objects, indent = 2) {
+    downloadFile(`${fileBaseName}.json`, formatJSON(objects, indent), 'application/json');
+}
+/**
+ * Download string content to the specified file with desired mime type.
+ *
+ * @param fileName full filename (including appropriate extension) of destination file
+ * @param contents string contents to be written to download destination
+ * @param mimeType mime type appropriate to file content to support consumption of destination file
+ */
+export function downloadFile(fileName, contents, mimeType = 'text/plain') {
+    if (!fileName || !contents) {
+        return;
+    }
+    // Create blob object and assign URL
+    const blob = new Blob([contents], { type: mimeType });
+    const url = window.URL.createObjectURL(blob);
+    // Construct anchor for URL, append to DOM, click and cleanup.
+    const a = document.createElement('a');
+    a.setAttribute('style', 'display: none');
+    a.setAttribute('download', fileName);
+    a.href = url;
+    document.body.appendChild(a);
+    a.click();
+    window.URL.revokeObjectURL(url);
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/functions/file.mjs

@@ -0,0 +1,16 @@
+/**
+ * Read file as UTF-8 text. Return string contents on read completion.
+ *
+ * @param file filename or File object
+ * @returns promise that resolves to file content string
+ */
+export function readFile(file) {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.readAsText(file, 'UTF-8');
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9jb3JlL2NvbW1vbi9mdW5jdGlvbnMvZmlsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQUMsSUFBVTtJQUNqQyxPQUFPLElBQUksT0FBTyxDQUFTLENBQUMsT0FBZ0MsRUFBRSxFQUFFO1FBQzlELE1BQU0sTUFBTSxHQUFlLElBQUksVUFBVSxFQUFFLENBQUM7UUFDNUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDakMsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUFHLEVBQUU7WUFDbkIsT0FBTyxDQUFTLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNqQyxDQUFDLENBQUM7SUFDSixDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJlYWQgZmlsZSBhcyBVVEYtOCB0ZXh0LiBSZXR1cm4gc3RyaW5nIGNvbnRlbnRzIG9uIHJlYWQgY29tcGxldGlvbi5cbiAqXG4gKiBAcGFyYW0gZmlsZSBmaWxlbmFtZSBvciBGaWxlIG9iamVjdFxuICogQHJldHVybnMgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHRvIGZpbGUgY29udGVudCBzdHJpbmdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlYWRGaWxlKGZpbGU6IEZpbGUpOiBQcm9taXNlPHN0cmluZz4ge1xuICByZXR1cm4gbmV3IFByb21pc2U8c3RyaW5nPigocmVzb2x2ZTogKHZhbHVlOiBzdHJpbmcpID0+IHZvaWQpID0+IHtcbiAgICBjb25zdCByZWFkZXI6IEZpbGVSZWFkZXIgPSBuZXcgRmlsZVJlYWRlcigpO1xuICAgIHJlYWRlci5yZWFkQXNUZXh0KGZpbGUsICdVVEYtOCcpO1xuICAgIHJlYWRlci5vbmxvYWQgPSAoKSA9PiB7XG4gICAgICByZXNvbHZlKDxzdHJpbmc+cmVhZGVyLnJlc3VsdCk7XG4gICAgfTtcbiAgfSk7XG59XG4iXX0=

package/esm2020/common/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vY29yZS9jb21tb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/common/pipes/bytes/bytes.pipe.mjs

@@ -0,0 +1,32 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdBytesPipe {
+    /* `bytes` needs to be `any` or TypeScript complains
+    Tried both `number` and `number | string` */
+    transform(bytes, precision = 2) {
+        if (bytes === 0) {
+            return '0 B';
+        }
+        else if (isNaN(parseInt(bytes, 10))) {
+            /* If not a valid number, return 'Invalid Number' */
+            return 'Invalid Number';
+        }
+        const k = 1024;
+        const sizes = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        // if less than 1
+        if (i < 0) {
+            return 'Invalid Number';
+        }
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(precision)) + ' ' + sizes[i];
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdBytesPipe.ɵfac = function TdBytesPipe_Factory(t) { return new (t || TdBytesPipe)(); };
+/** @nocollapse */ /** @nocollapse */ TdBytesPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "bytes", type: TdBytesPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdBytesPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'bytes',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/decimal-bytes/decimal-bytes.pipe.mjs

@@ -0,0 +1,32 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdDecimalBytesPipe {
+    /* `bytes` needs to be `any` or TypeScript complains
+    Tried both `number` and `number | string` */
+    transform(bytes, precision = 2) {
+        if (bytes === 0) {
+            return '0 B';
+        }
+        else if (isNaN(parseInt(bytes, 10))) {
+            /* If not a valid number, return 'Invalid Number' */
+            return 'Invalid Number';
+        }
+        const k = 1000;
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        // if less than 1
+        if (i < 0) {
+            return 'Invalid Number';
+        }
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(precision)) + ' ' + sizes[i];
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDecimalBytesPipe.ɵfac = function TdDecimalBytesPipe_Factory(t) { return new (t || TdDecimalBytesPipe)(); };
+/** @nocollapse */ /** @nocollapse */ TdDecimalBytesPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "decimalBytes", type: TdDecimalBytesPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDecimalBytesPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'decimalBytes',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/digits/digits.pipe.mjs

@@ -0,0 +1,39 @@
+import { Pipe, Inject, LOCALE_ID } from '@angular/core';
+import { DecimalPipe } from '@angular/common';
+import * as i0 from "@angular/core";
+export class TdDigitsPipe {
+    constructor(_locale = 'en') {
+        this._locale = _locale;
+        this._decimalPipe = new DecimalPipe(this._locale);
+    }
+    /* `digits` needs to be type `digits: any` or TypeScript complains */
+    transform(digits, precision = 1) {
+        if (digits === 0) {
+            return '0';
+        }
+        else if (isNaN(parseInt(digits, 10))) {
+            /* If not a valid number, return the value */
+            return digits;
+        }
+        else if (digits < 1) {
+            return this._decimalPipe.transform(digits.toFixed(precision));
+        }
+        const k = 1000;
+        const sizes = ['', 'K', 'M', 'B', 'T', 'Q'];
+        const i = Math.floor(Math.log(digits) / Math.log(k));
+        const size = sizes[i];
+        return (this._decimalPipe.transform(parseFloat((digits / Math.pow(k, i)).toFixed(precision))) + (size ? ' ' + size : ''));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDigitsPipe.ɵfac = function TdDigitsPipe_Factory(t) { return new (t || TdDigitsPipe)(i0.ɵɵdirectiveInject(LOCALE_ID, 16)); };
+/** @nocollapse */ /** @nocollapse */ TdDigitsPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "digits", type: TdDigitsPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDigitsPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'digits',
+            }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [LOCALE_ID]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/time-ago/time-ago.pipe.mjs

@@ -0,0 +1,72 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdTimeAgoPipe {
+    transform(time, reference) {
+        // Convert time to date object if not already
+        time = new Date(time);
+        const ref = new Date(reference);
+        // If not a valid timestamp, return 'Invalid Date'
+        if (!time.getTime()) {
+            return 'Invalid Date';
+        }
+        // For unit testing, we need to be able to declare a static start time
+        // for calculations, or else speed of tests can bork.
+        const startTime = isNaN(ref.getTime()) ? Date.now() : ref.getTime();
+        let diff = Math.floor((startTime - time.getTime()) / 1000);
+        if (diff < 2) {
+            return '1 second ago';
+        }
+        if (diff < 60) {
+            return Math.floor(diff) + ' seconds ago';
+        }
+        // Minutes
+        diff = diff / 60;
+        if (diff < 2) {
+            return '1 minute ago';
+        }
+        if (diff < 60) {
+            return Math.floor(diff) + ' minutes ago';
+        }
+        // Hours
+        diff = diff / 60;
+        if (diff < 2) {
+            return '1 hour ago';
+        }
+        if (diff < 24) {
+            return Math.floor(diff) + ' hours ago';
+        }
+        // Days
+        diff = diff / 24;
+        if (diff < 2) {
+            return '1 day ago';
+        }
+        if (diff < 30) {
+            return Math.floor(diff) + ' days ago';
+        }
+        // Months
+        diff = diff / 30;
+        if (diff < 2) {
+            return '1 month ago';
+        }
+        if (diff < 12) {
+            return Math.floor(diff) + ' months ago';
+        }
+        // Years
+        diff = diff / 12;
+        if (diff < 2) {
+            return '1 year ago';
+        }
+        else {
+            return Math.floor(diff) + ' years ago';
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdTimeAgoPipe.ɵfac = function TdTimeAgoPipe_Factory(t) { return new (t || TdTimeAgoPipe)(); };
+/** @nocollapse */ /** @nocollapse */ TdTimeAgoPipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "timeAgo", type: TdTimeAgoPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdTimeAgoPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'timeAgo',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/pipes/time-difference/time-difference.pipe.mjs

@@ -0,0 +1,51 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TdTimeDifferencePipe {
+    transform(start, end) {
+        const startTime = new Date(start);
+        let endTime;
+        if (end !== undefined) {
+            endTime = new Date(end);
+        }
+        else {
+            endTime = new Date();
+        }
+        if (!startTime.getTime() || !endTime.getTime()) {
+            return 'Invalid Date';
+        }
+        let diff = Math.floor((endTime.getTime() - startTime.getTime()) / 1000);
+        const days = Math.floor(diff / (60 * 60 * 24));
+        diff = diff - days * (60 * 60 * 24);
+        const hours = Math.floor(diff / (60 * 60));
+        diff = diff - hours * (60 * 60);
+        const minutes = Math.floor(diff / 60);
+        diff -= minutes * 60;
+        const seconds = diff;
+        const pad = '00';
+        let daysFormatted = '';
+        if (days > 0 && days < 2) {
+            daysFormatted = ' day - ';
+        }
+        else if (days > 1) {
+            daysFormatted = ' days - ';
+        }
+        return ((days > 0 ? days + daysFormatted : daysFormatted) +
+            pad.substring(0, pad.length - (hours + '').length) +
+            hours +
+            ':' +
+            pad.substring(0, pad.length - (minutes + '').length) +
+            minutes +
+            ':' +
+            pad.substring(0, pad.length - (seconds + '').length) +
+            seconds);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdTimeDifferencePipe.ɵfac = function TdTimeDifferencePipe_Factory(t) { return new (t || TdTimeDifferencePipe)(); };
+/** @nocollapse */ /** @nocollapse */ TdTimeDifferencePipe.ɵpipe = /** @pureOrBreakMyCode */ i0.ɵɵdefinePipe({ name: "timeDifference", type: TdTimeDifferencePipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdTimeDifferencePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'timeDifference',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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