@deenruv/admin-ui 1.0.0

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

@@ -0,0 +1,54 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/permissions/permissions.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(permissionsService, changeDetectorRef) {
+        this.permissionsService = permissionsService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.hasPermission = false;
+        this.lastPermissions = null;
+    }
+    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.permissionsService.currentUserPermissions$.subscribe(() => {
+                this.hasPermission = this.permissionsService.userHasPermissions(requiredPermissions);
+                this.changeDetectorRef.markForCheck();
+            });
+        }
+        return this.hasPermission;
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    dispose() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HasPermissionPipe, deps: [{ token: i1.PermissionsService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: HasPermissionPipe, name: "hasPermission", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HasPermissionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'hasPermission',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.PermissionsService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleBasePipe, deps: [{ token: i1.DataService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleBasePipe }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleBasePipe, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DataService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,60 @@
+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);
+        if (display === 'full' || display === 'name') {
+            name =
+                new Intl.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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyNamePipe, name: "localeCurrencyName", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeCurrencyName',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+import { Optional, Pipe } from '@angular/core';
+import { LocaleBasePipe } from './locale-base.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/currency/currency.service";
+import * as i2 from "../../data/providers/data.service";
+/**
+ * @description
+ * Formats a Deenruv 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(currencyService, dataService, changeDetectorRef) {
+        super(dataService, changeDetectorRef);
+        this.currencyService = currencyService;
+    }
+    transform(value, ...args) {
+        const [currencyCode, locale] = args;
+        if (typeof value === 'number') {
+            const activeLocale = this.getActiveLocale(locale);
+            const majorUnits = this.currencyService.toMajorUnits(value);
+            try {
+                return new Intl.NumberFormat(activeLocale, {
+                    style: 'currency',
+                    currency: currencyCode,
+                    minimumFractionDigits: this.currencyService.precision,
+                    maximumFractionDigits: this.currencyService.precision,
+                }).format(majorUnits);
+            }
+            catch (e) {
+                return majorUnits.toFixed(this.currencyService.precision);
+            }
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyPipe, deps: [{ token: i1.CurrencyService }, { token: i2.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyPipe, name: "localeCurrency", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeCurrency',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.CurrencyService }, { type: i2.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,90 @@
+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 'shortDate':
+                return {
+                    day: 'numeric',
+                    month: 'numeric',
+                    year: '2-digit',
+                };
+            case 'short':
+                return {
+                    day: 'numeric',
+                    month: 'numeric',
+                    year: '2-digit',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    hour12: true,
+                };
+            default:
+                return;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleDatePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocaleDatePipe, name: "localeDate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeDate',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleLanguageNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocaleLanguageNamePipe, name: "localeLanguageName", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleLanguageNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeLanguageName',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleRegionNamePipe, deps: [{ token: i1.DataService, optional: true }, { token: i0.ChangeDetectorRef, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: LocaleRegionNamePipe, name: "localeRegionName", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleRegionNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localeRegionName',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SentenceCasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: SentenceCasePipe, name: "sentenceCase" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", 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/esm2022/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;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SortPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: SortPipe, name: "sort" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SortPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sort',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/pipes/state-i18n-token.pipe.mjs

@@ -0,0 +1,54 @@
+import { Pipe } from '@angular/core';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import * as i0 from "@angular/core";
+export class StateI18nTokenPipe {
+    constructor() {
+        this.stateI18nTokens = {
+            Created: _('state.created'),
+            Draft: _('state.draft'),
+            AddingItems: _('state.adding-items'),
+            ArrangingPayment: _('state.arranging-payment'),
+            PaymentAuthorized: _('state.payment-authorized'),
+            PaymentSettled: _('state.payment-settled'),
+            PartiallyShipped: _('state.partially-shipped'),
+            Shipped: _('state.shipped'),
+            PartiallyDelivered: _('state.partially-delivered'),
+            Authorized: _('state.authorized'),
+            Delivered: _('state.delivered'),
+            Cancelled: _('state.cancelled'),
+            Pending: _('state.pending'),
+            Settled: _('state.settled'),
+            Failed: _('state.failed'),
+            Error: _('state.error'),
+            Declined: _('state.declined'),
+            Modifying: _('state.modifying'),
+            ArrangingAdditionalPayment: _('state.arranging-additional-payment'),
+        };
+    }
+    transform(value) {
+        if (typeof value === 'string' && value.length) {
+            const defaultStateToken = this.stateI18nTokens[value];
+            if (defaultStateToken) {
+                return defaultStateToken;
+            }
+            return getOrderStateTranslationToken(value);
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StateI18nTokenPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: StateI18nTokenPipe, name: "stateI18nToken" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StateI18nTokenPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'stateI18nToken',
+                }]
+        }] });
+export function getOrderStateTranslationToken(state) {
+    return ('state.' +
+        state
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/ +/g, '-')
+            .toLowerCase());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/pipes/string-to-color.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import { stringToColor } from '../../common/utilities/string-to-color';
+import * as i0 from "@angular/core";
+export class StringToColorPipe {
+    transform(value) {
+        return stringToColor(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StringToColorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: StringToColorPipe, name: "stringToColor" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StringToColorPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'stringToColor',
+                    pure: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXRvLWNvbG9yLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9waXBlcy9zdHJpbmctdG8tY29sb3IucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUVwRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7O0FBTXZFLE1BQU0sT0FBTyxpQkFBaUI7SUFDMUIsU0FBUyxDQUFDLEtBQVU7UUFDaEIsT0FBTyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDaEMsQ0FBQzsrR0FIUSxpQkFBaUI7NkdBQWpCLGlCQUFpQjs7NEZBQWpCLGlCQUFpQjtrQkFKN0IsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsZUFBZTtvQkFDckIsSUFBSSxFQUFFLElBQUk7aUJBQ2IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IHN0cmluZ1RvQ29sb3IgfSBmcm9tICcuLi8uLi9jb21tb24vdXRpbGl0aWVzL3N0cmluZy10by1jb2xvcic7XG5cbkBQaXBlKHtcbiAgICBuYW1lOiAnc3RyaW5nVG9Db2xvcicsXG4gICAgcHVyZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgU3RyaW5nVG9Db2xvclBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgICB0cmFuc2Zvcm0odmFsdWU6IGFueSk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBzdHJpbmdUb0NvbG9yKHZhbHVlKTtcbiAgICB9XG59XG4iXX0=