@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/core/shared/pipes/file-size.pipe.mjs

@@ -0,0 +1,47 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Formats a number into a human-readable file size string.
+ *
+ * @example
+ * ```TypeScript
+ * {{ fileSizeInBytes | filesize }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class FileSizePipe {
+    transform(value, useSiUnits = true) {
+        if (typeof value !== 'number' && typeof value !== 'string') {
+            return value;
+        }
+        return humanFileSize(value, useSiUnits === true);
+    }
+}
+FileSizePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FileSizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+FileSizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FileSizePipe, name: "filesize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'filesize' }]
+        }] });
+/**
+ * Convert a number into a human-readable file size string.
+ * Adapted from http://stackoverflow.com/a/14919494/772859
+ */
+function humanFileSize(bytes, si) {
+    const thresh = si ? 1000 : 1024;
+    if (Math.abs(bytes) < thresh) {
+        return bytes + ' B';
+    }
+    const units = si
+        ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    let u = -1;
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.abs(bytes) >= thresh && u < units.length - 1);
+    return bytes.toFixed(1) + ' ' + units[u];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/has-permission.pipe.mjs

@@ -0,0 +1,65 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * A pipe which checks the provided permission against all the permissions of the current user.
+ * Returns `true` if the current user has that permission.
+ *
+ * @example
+ * ```HTML
+ * <button [disabled]="!('UpdateCatalog' | hasPermission)">Save Changes</button>
+ * ```
+ * @docsCategory pipes
+ */
+export class HasPermissionPipe {
+    constructor(dataService, changeDetectorRef) {
+        this.dataService = dataService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.hasPermission = false;
+        this.lastPermissions = null;
+        this.currentPermissions$ = this.dataService.client
+            .userStatus()
+            .mapStream(data => data.userStatus.permissions);
+    }
+    transform(input) {
+        const requiredPermissions = Array.isArray(input) ? input : [input];
+        const requiredPermissionsString = requiredPermissions.join(',');
+        if (this.lastPermissions !== requiredPermissionsString) {
+            this.lastPermissions = requiredPermissionsString;
+            this.hasPermission = false;
+            this.dispose();
+            this.subscription = this.currentPermissions$.subscribe(permissions => {
+                this.hasPermission = this.checkPermissions(permissions, requiredPermissions);
+                this.changeDetectorRef.markForCheck();
+            });
+        }
+        return this.hasPermission;
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    checkPermissions(userPermissions, requiredPermissions) {
+        for (const perm of requiredPermissions) {
+            if (userPermissions.includes(perm)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    dispose() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+}
+HasPermissionPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: HasPermissionPipe, deps: [{ token: i1.DataService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+HasPermissionPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: HasPermissionPipe, name: "hasPermission", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: HasPermissionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'hasPermission',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-base.pipe.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * Used by locale-aware pipes to handle the task of getting the active languageCode
+ * of the UI and cleaning up.
+ */
+export class LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        if (dataService && changeDetectorRef) {
+            this.subscription = dataService.client
+                .uiState()
+                .mapStream(data => data.uiState)
+                .subscribe(({ language, locale }) => {
+                this.locale = language.replace(/_/g, '-');
+                if (locale) {
+                    this.locale += `-${locale}`;
+                }
+                changeDetectorRef.markForCheck();
+            });
+        }
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /**
+     * Returns the active locale after attempting to ensure that the locale string
+     * is valid for the Intl API.
+     */
+    getActiveLocale(localeOverride) {
+        const locale = typeof localeOverride === 'string' ? localeOverride : this.locale ?? 'en';
+        const hyphenated = locale?.replace(/_/g, '-');
+        // Check for a double-region string, containing 2 region codes like
+        // pt-BR-BR, which is invalid. In this case, the second region is used
+        // and the first region discarded. This would only ever be an issue for
+        // those languages where the translation file itself encodes the region,
+        // as in pt_BR & pt_PT.
+        const matches = hyphenated?.match(/^([a-zA-Z_-]+)(-[A-Z][A-Z])(-[A-Z][A-z])$/);
+        if (matches?.length) {
+            const overriddenLocale = matches[1] + matches[3];
+            return overriddenLocale;
+        }
+        else {
+            return hyphenated;
+        }
+    }
+}
+LocaleBasePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleBasePipe, deps: [{ token: i1.DataService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Injectable });
+LocaleBasePipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleBasePipe });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleBasePipe, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-currency-name.pipe.mjs

@@ -0,0 +1,61 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * Displays a human-readable name for a given ISO 4217 currency code.
+ *
+ * @example
+ * ```HTML
+ * {{ order.currencyCode | localeCurrencyName }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class LocaleCurrencyNamePipe extends LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+    }
+    transform(value, display = 'full', locale) {
+        if (value == null || value === '') {
+            return '';
+        }
+        if (typeof value !== 'string') {
+            return `Invalid currencyCode "${value}"`;
+        }
+        let name = '';
+        let symbol = '';
+        const activeLocale = this.getActiveLocale(locale);
+        // Awaiting TS types for this API: https://github.com/microsoft/TypeScript/pull/44022/files
+        const DisplayNames = Intl.DisplayNames;
+        if (display === 'full' || display === 'name') {
+            name = new DisplayNames([activeLocale], {
+                type: 'currency',
+            }).of(value);
+        }
+        if (display === 'full' || display === 'symbol') {
+            const parts = new Intl.NumberFormat(activeLocale, {
+                style: 'currency',
+                currency: value,
+                currencyDisplay: 'symbol',
+            }).formatToParts();
+            symbol = parts.find(p => p.type === 'currency')?.value || value;
+        }
+        return display === 'full' ? `${name} (${symbol})` : display === 'name' ? name : symbol;
+    }
+}
+LocaleCurrencyNamePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocaleCurrencyNamePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyNamePipe, name: "localeCurrencyName", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeCurrencyName',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-currency.pipe.mjs

@@ -0,0 +1,44 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * Formats a Vendure monetary value (in cents) into the correct format for the configured currency and display
+ * locale.
+ *
+ * @example
+ * ```HTML
+ * {{ variant.priceWithTax | localeCurrency }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class LocaleCurrencyPipe extends LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+    }
+    transform(value, ...args) {
+        const [currencyCode, locale] = args;
+        if (typeof value === 'number' && typeof currencyCode === 'string') {
+            const activeLocale = this.getActiveLocale(locale);
+            const majorUnits = value / 100;
+            return new Intl.NumberFormat(activeLocale, { style: 'currency', currency: currencyCode }).format(majorUnits);
+        }
+        return value;
+    }
+}
+LocaleCurrencyPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyPipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocaleCurrencyPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyPipe, name: "localeCurrency", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeCurrency',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-date.pipe.mjs

@@ -0,0 +1,84 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * A replacement of the Angular DatePipe which makes use of the Intl API
+ * to format dates according to the selected UI language.
+ *
+ * @example
+ * ```HTML
+ * {{ order.orderPlacedAt | localeDate }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class LocaleDatePipe extends LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+    }
+    transform(value, ...args) {
+        const [format, locale] = args;
+        if (this.locale || typeof locale === 'string') {
+            const activeLocale = this.getActiveLocale(locale);
+            const date = value instanceof Date ? value : typeof value === 'string' ? new Date(value) : undefined;
+            if (date) {
+                const options = this.getOptionsForFormat(typeof format === 'string' ? format : 'medium');
+                return new Intl.DateTimeFormat(activeLocale, options).format(date);
+            }
+        }
+    }
+    getOptionsForFormat(dateFormat) {
+        switch (dateFormat) {
+            case 'medium':
+                return {
+                    month: 'short',
+                    year: 'numeric',
+                    day: 'numeric',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                    hour12: true,
+                };
+            case 'mediumTime':
+                return {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                    hour12: true,
+                };
+            case 'longDate':
+                return {
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                };
+            case 'short':
+                return {
+                    day: 'numeric',
+                    month: 'numeric',
+                    year: '2-digit',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    hour12: true,
+                };
+            default:
+                return;
+        }
+    }
+}
+LocaleDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleDatePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocaleDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleDatePipe, name: "localeDate", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeDate',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-language-name.pipe.mjs

@@ -0,0 +1,51 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * Displays a human-readable name for a given ISO 639-1 language code.
+ *
+ * @example
+ * ```HTML
+ * {{ 'zh_Hant' | localeLanguageName }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class LocaleLanguageNamePipe extends LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+    }
+    transform(value, locale) {
+        if (value == null || value === '') {
+            return '';
+        }
+        if (typeof value !== 'string') {
+            return `Invalid language code "${value}"`;
+        }
+        const activeLocale = this.getActiveLocale(locale);
+        // Awaiting TS types for this API: https://github.com/microsoft/TypeScript/pull/44022/files
+        const DisplayNames = Intl.DisplayNames;
+        try {
+            return new DisplayNames([activeLocale.replace('_', '-')], { type: 'language' }).of(value.replace('_', '-'));
+        }
+        catch (e) {
+            return value;
+        }
+    }
+}
+LocaleLanguageNamePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleLanguageNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocaleLanguageNamePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleLanguageNamePipe, name: "localeLanguageName", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleLanguageNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeLanguageName',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/locale-region-name.pipe.mjs

@@ -0,0 +1,51 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+/**
+ * @description
+ * Displays a human-readable name for a given region.
+ *
+ * @example
+ * ```HTML
+ * {{ 'GB' | localeRegionName }}
+ * ```
+ *
+ * @docsCategory pipes
+ */
+export class LocaleRegionNamePipe extends LocaleBasePipe {
+    constructor(dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+    }
+    transform(value, locale) {
+        if (value == null || value === '') {
+            return '';
+        }
+        if (typeof value !== 'string') {
+            return `Invalid region code "${value}"`;
+        }
+        const activeLocale = this.getActiveLocale(locale);
+        // Awaiting TS types for this API: https://github.com/microsoft/TypeScript/pull/44022/files
+        const DisplayNames = Intl.DisplayNames;
+        try {
+            return new DisplayNames([activeLocale.replace('_', '-')], { type: 'region' }).of(value.replace('_', '-'));
+        }
+        catch (e) {
+            return value;
+        }
+    }
+}
+LocaleRegionNamePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleRegionNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocaleRegionNamePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleRegionNamePipe, name: "localeRegionName", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocaleRegionNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeRegionName',
+                    pure: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxlLXJlZ2lvbi1uYW1lLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9waXBlcy9sb2NhbGUtcmVnaW9uLW5hbWUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXFCLFFBQVEsRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBSWpGLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7O0FBRXBEOzs7Ozs7Ozs7O0dBVUc7QUFLSCxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsY0FBYztJQUNwRCxZQUF3QixXQUF5QixFQUFjLGlCQUFxQztRQUNoRyxLQUFLLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUNELFNBQVMsQ0FBQyxLQUFVLEVBQUUsTUFBZ0I7UUFDbEMsSUFBSSxLQUFLLElBQUksSUFBSSxJQUFJLEtBQUssS0FBSyxFQUFFLEVBQUU7WUFDL0IsT0FBTyxFQUFFLENBQUM7U0FDYjtRQUNELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO1lBQzNCLE9BQU8sd0JBQXdCLEtBQVksR0FBRyxDQUFDO1NBQ2xEO1FBQ0QsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVsRCwyRkFBMkY7UUFDM0YsTUFBTSxZQUFZLEdBQUksSUFBWSxDQUFDLFlBQVksQ0FBQztRQUVoRCxJQUFJO1lBQ0EsT0FBTyxJQUFJLFlBQVksQ0FBQyxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQzVFLEtBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUMxQixDQUFDO1NBQ0w7UUFBQyxPQUFPLENBQU0sRUFBRTtZQUNiLE9BQU8sS0FBSyxDQUFDO1NBQ2hCO0lBQ0wsQ0FBQzs7aUhBdkJRLG9CQUFvQjsrR0FBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBSmhDLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLGtCQUFrQjtvQkFDeEIsSUFBSSxFQUFFLEtBQUs7aUJBQ2Q7OzBCQUVnQixRQUFROzswQkFBK0IsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdG9yUmVmLCBPcHRpb25hbCwgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuaW1wb3J0IHsgRGF0YVNlcnZpY2UgfSBmcm9tICcuLi8uLi9kYXRhL3Byb3ZpZGVycy9kYXRhLnNlcnZpY2UnO1xyXG5cclxuaW1wb3J0IHsgTG9jYWxlQmFzZVBpcGUgfSBmcm9tICcuL2xvY2FsZS1iYXNlLnBpcGUnO1xyXG5cclxuLyoqXHJcbiAqIEBkZXNjcmlwdGlvblxyXG4gKiBEaXNwbGF5cyBhIGh1bWFuLXJlYWRhYmxlIG5hbWUgZm9yIGEgZ2l2ZW4gcmVnaW9uLlxyXG4gKlxyXG4gKiBAZXhhbXBsZVxyXG4gKiBgYGBIVE1MXHJcbiAqIHt7ICdHQicgfCBsb2NhbGVSZWdpb25OYW1lIH19XHJcbiAqIGBgYFxyXG4gKlxyXG4gKiBAZG9jc0NhdGVnb3J5IHBpcGVzXHJcbiAqL1xyXG5AUGlwZSh7XHJcbiAgICBuYW1lOiAnbG9jYWxlUmVnaW9uTmFtZScsXHJcbiAgICBwdXJlOiBmYWxzZSxcclxufSlcclxuZXhwb3J0IGNsYXNzIExvY2FsZVJlZ2lvbk5hbWVQaXBlIGV4dGVuZHMgTG9jYWxlQmFzZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICAgIGNvbnN0cnVjdG9yKEBPcHRpb25hbCgpIGRhdGFTZXJ2aWNlPzogRGF0YVNlcnZpY2UsIEBPcHRpb25hbCgpIGNoYW5nZURldGVjdG9yUmVmPzogQ2hhbmdlRGV0ZWN0b3JSZWYpIHtcclxuICAgICAgICBzdXBlcihkYXRhU2VydmljZSwgY2hhbmdlRGV0ZWN0b3JSZWYpO1xyXG4gICAgfVxyXG4gICAgdHJhbnNmb3JtKHZhbHVlOiBhbnksIGxvY2FsZT86IHVua25vd24pOiBzdHJpbmcge1xyXG4gICAgICAgIGlmICh2YWx1ZSA9PSBudWxsIHx8IHZhbHVlID09PSAnJykge1xyXG4gICAgICAgICAgICByZXR1cm4gJyc7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIGlmICh0eXBlb2YgdmFsdWUgIT09ICdzdHJpbmcnKSB7XHJcbiAgICAgICAgICAgIHJldHVybiBgSW52YWxpZCByZWdpb24gY29kZSBcIiR7dmFsdWUgYXMgYW55fVwiYDtcclxuICAgICAgICB9XHJcbiAgICAgICAgY29uc3QgYWN0aXZlTG9jYWxlID0gdGhpcy5nZXRBY3RpdmVMb2NhbGUobG9jYWxlKTtcclxuXHJcbiAgICAgICAgLy8gQXdhaXRpbmcgVFMgdHlwZXMgZm9yIHRoaXMgQVBJOiBodHRwczovL2dpdGh1Yi5jb20vbWljcm9zb2Z0L1R5cGVTY3JpcHQvcHVsbC80NDAyMi9maWxlc1xyXG4gICAgICAgIGNvbnN0IERpc3BsYXlOYW1lcyA9IChJbnRsIGFzIGFueSkuRGlzcGxheU5hbWVzO1xyXG5cclxuICAgICAgICB0cnkge1xyXG4gICAgICAgICAgICByZXR1cm4gbmV3IERpc3BsYXlOYW1lcyhbYWN0aXZlTG9jYWxlLnJlcGxhY2UoJ18nLCAnLScpXSwgeyB0eXBlOiAncmVnaW9uJyB9KS5vZihcclxuICAgICAgICAgICAgICAgIHZhbHVlLnJlcGxhY2UoJ18nLCAnLScpLFxyXG4gICAgICAgICAgICApO1xyXG4gICAgICAgIH0gY2F0Y2ggKGU6IGFueSkge1xyXG4gICAgICAgICAgICByZXR1cm4gdmFsdWU7XHJcbiAgICAgICAgfVxyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/core/shared/pipes/sentence-case.pipe.mjs

@@ -0,0 +1,30 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Formats a string into sentence case (first letter of first word uppercase).
+ */
+export class SentenceCasePipe {
+    transform(value) {
+        if (typeof value === 'string') {
+            let lower;
+            if (isCamelCase(value)) {
+                lower = value.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase();
+            }
+            else {
+                lower = value.toLowerCase();
+            }
+            return lower.charAt(0).toUpperCase() + lower.slice(1);
+        }
+        return value;
+    }
+}
+SentenceCasePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SentenceCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+SentenceCasePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SentenceCasePipe, name: "sentenceCase" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SentenceCasePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'sentenceCase' }]
+        }] });
+function isCamelCase(value) {
+    return /^[a-zA-Z]+[A-Z][a-zA-Z]+$/.test(value);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/shared/pipes/sort.pipe.mjs

@@ -0,0 +1,34 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A pipe for sorting elements of an array. Should be used with caution due to the
+ * potential for perf degredation. Ideally should only be used on small arrays (< 10s of items)
+ * and in components using OnPush change detection.
+ */
+export class SortPipe {
+    transform(value, orderByProp) {
+        return value.slice().sort((a, b) => {
+            const aProp = orderByProp ? a[orderByProp] : a;
+            const bProp = orderByProp ? b[orderByProp] : b;
+            if (aProp === bProp) {
+                return 0;
+            }
+            if (aProp == null) {
+                return 1;
+            }
+            if (bProp == null) {
+                return -1;
+            }
+            return aProp > bProp ? 1 : -1;
+        });
+    }
+}
+SortPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SortPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+SortPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SortPipe, name: "sort" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: SortPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sort',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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