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

package/esm2020/catalog/components/update-product-option-dialog/update-product-option-dialog.component.mjs

@@ -0,0 +1,64 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { createUpdatedTranslatable } from '@vendure/admin-ui/core';
+import { normalizeString } from '@vendure/common/lib/normalize-string';
+import * as i0 from "@angular/core";
+import * as i1 from "@vendure/admin-ui/core";
+import * as i2 from "@clr/angular";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-translate/core";
+export class UpdateProductOptionDialogComponent {
+    constructor() {
+        this.updateVariantName = true;
+        this.codeInputTouched = false;
+    }
+    ngOnInit() {
+        const currentTranslation = this.productOption.translations.find(t => t.languageCode === this.activeLanguage);
+        this.name = currentTranslation?.name ?? '';
+        this.code = this.productOption.code;
+        this.customFieldsForm = new FormGroup({});
+        if (this.customFields) {
+            const cfCurrentTranslation = (currentTranslation && currentTranslation.customFields) || {};
+            for (const fieldDef of this.customFields) {
+                const key = fieldDef.name;
+                const value = fieldDef.type === 'localeString'
+                    ? cfCurrentTranslation[key]
+                    : this.productOption.customFields[key];
+                this.customFieldsForm.addControl(fieldDef.name, new FormControl(value));
+            }
+        }
+    }
+    update() {
+        const result = createUpdatedTranslatable({
+            translatable: this.productOption,
+            languageCode: this.activeLanguage,
+            updatedFields: {
+                code: this.code,
+                name: this.name,
+                customFields: this.customFieldsForm.value,
+            },
+            customFieldConfig: this.customFields,
+            defaultTranslation: {
+                languageCode: this.activeLanguage,
+                name: '',
+            },
+        });
+        this.resolveWith({ ...result, autoUpdate: this.updateVariantName });
+    }
+    cancel() {
+        this.resolveWith();
+    }
+    updateCode(nameValue) {
+        if (!this.codeInputTouched && !this.productOption.code) {
+            this.code = normalizeString(nameValue, '-');
+        }
+    }
+}
+UpdateProductOptionDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: UpdateProductOptionDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+UpdateProductOptionDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: UpdateProductOptionDialogComponent, selector: "vdr-update-product-option-dialog", ngImport: i0, template: "<ng-template vdrDialogTitle>{{ 'catalog.update-product-option' | translate }}</ng-template>\r\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\r\n    <input\r\n        id=\"name\"\r\n        type=\"text\"\r\n        #nameInput=\"ngModel\"\r\n        [(ngModel)]=\"name\"\r\n        required\r\n        (input)=\"updateCode($event.target.value)\"\r\n    />\r\n</vdr-form-field>\r\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\r\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\r\n</vdr-form-field>\r\n<clr-checkbox-wrapper>\r\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\r\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\r\n</clr-checkbox-wrapper>\r\n<section *ngIf=\"customFields.length\">\r\n    <label>{{ 'common.custom-fields' | translate }}</label>\r\n    <vdr-tabbed-custom-fields\r\n        entityName=\"ProductOption\"\r\n        [customFields]=\"customFields\"\r\n        [customFieldsFormGroup]=\"customFieldsForm\"\r\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\r\n    ></vdr-tabbed-custom-fields>\r\n</section>\r\n\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\r\n    <button\r\n        type=\"submit\"\r\n        (click)=\"update()\"\r\n        [disabled]=\"\r\n            nameInput.invalid ||\r\n            codeInput.invalid ||\r\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\r\n        \"\r\n        class=\"btn btn-primary\"\r\n    >\r\n        {{ 'catalog.update-product-option' | translate }}\r\n    </button>\r\n</ng-template>\r\n", styles: [""], components: [{ type: i1.FormFieldComponent, selector: "vdr-form-field", inputs: ["label", "for", "tooltip", "errors", "readOnlyToggle"] }, { type: i2.ClrCheckboxWrapper, selector: "clr-checkbox-wrapper,clr-toggle-wrapper" }, { type: i1.TabbedCustomFieldsComponent, selector: "vdr-tabbed-custom-fields", inputs: ["entityName", "customFields", "customFieldsFormGroup", "readonly", "compact", "showLabel"] }], directives: [{ type: i1.DialogTitleDirective, selector: "[vdrDialogTitle]" }, { type: i1.FormFieldControlDirective, selector: "input, textarea, select" }, { type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i3.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { type: i3.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { type: i2.ClrCheckbox, selector: "[clrCheckbox],[clrToggle]" }, { type: i2.ClrLabel, selector: "label", inputs: ["for"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.DialogButtonsDirective, selector: "[vdrDialogButtons]" }], pipes: { "translate": i5.TranslatePipe, "hasPermission": i1.HasPermissionPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: UpdateProductOptionDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-update-product-option-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template vdrDialogTitle>{{ 'catalog.update-product-option' | translate }}</ng-template>\r\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\r\n    <input\r\n        id=\"name\"\r\n        type=\"text\"\r\n        #nameInput=\"ngModel\"\r\n        [(ngModel)]=\"name\"\r\n        required\r\n        (input)=\"updateCode($event.target.value)\"\r\n    />\r\n</vdr-form-field>\r\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\r\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\r\n</vdr-form-field>\r\n<clr-checkbox-wrapper>\r\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\r\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\r\n</clr-checkbox-wrapper>\r\n<section *ngIf=\"customFields.length\">\r\n    <label>{{ 'common.custom-fields' | translate }}</label>\r\n    <vdr-tabbed-custom-fields\r\n        entityName=\"ProductOption\"\r\n        [customFields]=\"customFields\"\r\n        [customFieldsFormGroup]=\"customFieldsForm\"\r\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\r\n    ></vdr-tabbed-custom-fields>\r\n</section>\r\n\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\r\n    <button\r\n        type=\"submit\"\r\n        (click)=\"update()\"\r\n        [disabled]=\"\r\n            nameInput.invalid ||\r\n            codeInput.invalid ||\r\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\r\n        \"\r\n        class=\"btn btn-primary\"\r\n    >\r\n        {{ 'catalog.update-product-option' | translate }}\r\n    </button>\r\n</ng-template>\r\n", styles: [""] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-product-option-dialog.component.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/update-product-option-dialog/update-product-option-dialog.component.ts","../../../../../src/lib/catalog/src/components/update-product-option-dialog/update-product-option-dialog.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAU,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAOxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;;;;;;;AAQvE,MAAM,OAAO,kCAAkC;IAN/C;QAUI,sBAAiB,GAAG,IAAI,CAAC;QAOzB,qBAAgB,GAAG,KAAK,CAAC;KAoD5B;IAjDG,QAAQ;QACJ,MAAM,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAC3D,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,IAAI,CAAC,cAAc,CAC9C,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,kBAAkB,EAAE,IAAI,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;QAC1C,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,MAAM,oBAAoB,GACtB,CAAC,kBAAkB,IAAK,kBAA0B,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YAE3E,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,YAAY,EAAE;gBACtC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC;gBAC1B,MAAM,KAAK,GACP,QAAQ,CAAC,IAAI,KAAK,cAAc;oBAC5B,CAAC,CAAC,oBAAoB,CAAC,GAAG,CAAC;oBAC3B,CAAC,CAAE,IAAI,CAAC,aAAqB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBACxD,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;aAC3E;SACJ;IACL,CAAC;IAED,MAAM;QACF,MAAM,MAAM,GAAG,yBAAyB,CAAC;YACrC,YAAY,EAAE,IAAI,CAAC,aAAa;YAChC,YAAY,EAAE,IAAI,CAAC,cAAc;YACjC,aAAa,EAAE;gBACX,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK;aAC5C;YACD,iBAAiB,EAAE,IAAI,CAAC,YAAY;YACpC,kBAAkB,EAAE;gBAChB,YAAY,EAAE,IAAI,CAAC,cAAc;gBACjC,IAAI,EAAE,EAAE;aACX;SACJ,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,EAAE,GAAG,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,MAAM;QACF,IAAI,CAAC,WAAW,EAAE,CAAC;IACvB,CAAC;IAED,UAAU,CAAC,SAAiB;QACxB,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;YACpD,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;SAC/C;IACL,CAAC;;+HA9DQ,kCAAkC;mHAAlC,kCAAkC,wEClB/C,+wDA2CA;2FDzBa,kCAAkC;kBAN9C,SAAS;+BACI,kCAAkC,mBAG3B,uBAAuB,CAAC,MAAM","sourcesContent":["import { ChangeDetectionStrategy, Component, OnInit } from '@angular/core';\r\nimport { FormControl, FormGroup } from '@angular/forms';\r\nimport {\r\n    CustomFieldConfig,\r\n    LanguageCode,\r\n    ProductVariantFragment,\r\n    UpdateProductOptionInput,\r\n} from '@vendure/admin-ui/core';\r\nimport { createUpdatedTranslatable } from '@vendure/admin-ui/core';\r\nimport { Dialog } from '@vendure/admin-ui/core';\r\nimport { normalizeString } from '@vendure/common/lib/normalize-string';\r\n\r\n@Component({\r\n    selector: 'vdr-update-product-option-dialog',\r\n    templateUrl: './update-product-option-dialog.component.html',\r\n    styleUrls: ['./update-product-option-dialog.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class UpdateProductOptionDialogComponent\r\n    implements Dialog<UpdateProductOptionInput & { autoUpdate: boolean }>, OnInit\r\n{\r\n    resolveWith: (result?: UpdateProductOptionInput & { autoUpdate: boolean }) => void;\r\n    updateVariantName = true;\r\n    // Provided by caller\r\n    productOption: ProductVariantFragment['options'][number];\r\n    activeLanguage: LanguageCode;\r\n    name: string;\r\n    code: string;\r\n    customFields: CustomFieldConfig[];\r\n    codeInputTouched = false;\r\n    customFieldsForm: FormGroup;\r\n\r\n    ngOnInit(): void {\r\n        const currentTranslation = this.productOption.translations.find(\r\n            t => t.languageCode === this.activeLanguage,\r\n        );\r\n        this.name = currentTranslation?.name ?? '';\r\n        this.code = this.productOption.code;\r\n        this.customFieldsForm = new FormGroup({});\r\n        if (this.customFields) {\r\n            const cfCurrentTranslation =\r\n                (currentTranslation && (currentTranslation as any).customFields) || {};\r\n\r\n            for (const fieldDef of this.customFields) {\r\n                const key = fieldDef.name;\r\n                const value =\r\n                    fieldDef.type === 'localeString'\r\n                        ? cfCurrentTranslation[key]\r\n                        : (this.productOption as any).customFields[key];\r\n                this.customFieldsForm.addControl(fieldDef.name, new FormControl(value));\r\n            }\r\n        }\r\n    }\r\n\r\n    update() {\r\n        const result = createUpdatedTranslatable({\r\n            translatable: this.productOption,\r\n            languageCode: this.activeLanguage,\r\n            updatedFields: {\r\n                code: this.code,\r\n                name: this.name,\r\n                customFields: this.customFieldsForm.value,\r\n            },\r\n            customFieldConfig: this.customFields,\r\n            defaultTranslation: {\r\n                languageCode: this.activeLanguage,\r\n                name: '',\r\n            },\r\n        });\r\n        this.resolveWith({ ...result, autoUpdate: this.updateVariantName });\r\n    }\r\n\r\n    cancel() {\r\n        this.resolveWith();\r\n    }\r\n\r\n    updateCode(nameValue: string) {\r\n        if (!this.codeInputTouched && !this.productOption.code) {\r\n            this.code = normalizeString(nameValue, '-');\r\n        }\r\n    }\r\n}\r\n","<ng-template vdrDialogTitle>{{ 'catalog.update-product-option' | translate }}</ng-template>\r\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\r\n    <input\r\n        id=\"name\"\r\n        type=\"text\"\r\n        #nameInput=\"ngModel\"\r\n        [(ngModel)]=\"name\"\r\n        required\r\n        (input)=\"updateCode($event.target.value)\"\r\n    />\r\n</vdr-form-field>\r\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\r\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\r\n</vdr-form-field>\r\n<clr-checkbox-wrapper>\r\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\r\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\r\n</clr-checkbox-wrapper>\r\n<section *ngIf=\"customFields.length\">\r\n    <label>{{ 'common.custom-fields' | translate }}</label>\r\n    <vdr-tabbed-custom-fields\r\n        entityName=\"ProductOption\"\r\n        [customFields]=\"customFields\"\r\n        [customFieldsFormGroup]=\"customFieldsForm\"\r\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\r\n    ></vdr-tabbed-custom-fields>\r\n</section>\r\n\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\r\n    <button\r\n        type=\"submit\"\r\n        (click)=\"update()\"\r\n        [disabled]=\"\r\n            nameInput.invalid ||\r\n            codeInput.invalid ||\r\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\r\n        \"\r\n        class=\"btn btn-primary\"\r\n    >\r\n        {{ 'catalog.update-product-option' | translate }}\r\n    </button>\r\n</ng-template>\r\n"]}

package/esm2020/catalog/components/variant-price-detail/variant-price-detail.component.mjs

@@ -0,0 +1,61 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@vendure/admin-ui/core";
+import * as i2 from "@clr/angular";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+export class VariantPriceDetailComponent {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this.priceChange$ = new BehaviorSubject(0);
+        this.taxCategoryIdChange$ = new BehaviorSubject('');
+    }
+    ngOnInit() {
+        const taxRates$ = this.dataService.settings
+            .getTaxRatesSimple(999, 0, 'cache-first')
+            .mapStream(data => data.taxRates.items);
+        const activeChannel$ = this.dataService.settings
+            .getActiveChannel('cache-first')
+            .refetchOnChannelChange()
+            .mapStream(data => data.activeChannel);
+        this.taxRate$ = combineLatest(activeChannel$, taxRates$, this.taxCategoryIdChange$).pipe(map(([channel, taxRates, taxCategoryId]) => {
+            const defaultTaxZone = channel.defaultTaxZone;
+            if (!defaultTaxZone) {
+                return 0;
+            }
+            const applicableRate = taxRates.find(taxRate => taxRate.zone.id === defaultTaxZone.id && taxRate.category.id === taxCategoryId);
+            if (!applicableRate) {
+                return 0;
+            }
+            return applicableRate.value;
+        }));
+        this.grossPrice$ = combineLatest(this.taxRate$, this.priceChange$).pipe(map(([taxRate, price]) => {
+            return Math.round(price * ((100 + taxRate) / 100));
+        }));
+    }
+    ngOnChanges(changes) {
+        if ('price' in changes) {
+            this.priceChange$.next(changes.price.currentValue);
+        }
+        if ('taxCategoryId' in changes) {
+            this.taxCategoryIdChange$.next(changes.taxCategoryId.currentValue);
+        }
+    }
+}
+VariantPriceDetailComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: VariantPriceDetailComponent, deps: [{ token: i1.DataService }], target: i0.ɵɵFactoryTarget.Component });
+VariantPriceDetailComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: VariantPriceDetailComponent, selector: "vdr-variant-price-detail", inputs: { priceIncludesTax: "priceIncludesTax", price: "price", currencyCode: "currencyCode", taxCategoryId: "taxCategoryId" }, usesOnChanges: true, ngImport: i0, template: "<label class=\"clr-control-label\">{{ 'catalog.taxes' | translate }}</label>\r\n<div *ngIf=\"priceIncludesTax\" class=\"value\">\r\n    {{ 'catalog.price-includes-tax-at' | translate: { rate: taxRate$ | async } }}\r\n</div>\r\n<div *ngIf=\"!priceIncludesTax\" class=\"value\">\r\n    {{\r\n        'catalog.price-with-tax-in-default-zone'\r\n            | translate: { price: grossPrice$ | async | localeCurrency: currencyCode, rate: taxRate$ | async }\r\n    }}\r\n</div>\r\n", styles: [":host{display:flex;flex-direction:column}.value{margin-top:3px}\n"], directives: [{ type: i2.ClrLabel, selector: "label", inputs: ["for"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i4.TranslatePipe, "async": i3.AsyncPipe, "localeCurrency": i1.LocaleCurrencyPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: VariantPriceDetailComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-variant-price-detail', changeDetection: ChangeDetectionStrategy.OnPush, template: "<label class=\"clr-control-label\">{{ 'catalog.taxes' | translate }}</label>\r\n<div *ngIf=\"priceIncludesTax\" class=\"value\">\r\n    {{ 'catalog.price-includes-tax-at' | translate: { rate: taxRate$ | async } }}\r\n</div>\r\n<div *ngIf=\"!priceIncludesTax\" class=\"value\">\r\n    {{\r\n        'catalog.price-with-tax-in-default-zone'\r\n            | translate: { price: grossPrice$ | async | localeCurrency: currencyCode, rate: taxRate$ | async }\r\n    }}\r\n</div>\r\n", styles: [":host{display:flex;flex-direction:column}.value{margin-top:3px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }]; }, propDecorators: { priceIncludesTax: [{
+                type: Input
+            }], price: [{
+                type: Input
+            }], currencyCode: [{
+                type: Input
+            }], taxCategoryId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/catalog/providers/product-detail/product-detail.service.mjs

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { DeletionResult, findTranslation, } from '@vendure/admin-ui/core';
+import { normalizeString } from '@vendure/common/lib/normalize-string';
+import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
+import { forkJoin, of, throwError } from 'rxjs';
+import { map, mergeMap, shareReplay, switchMap } from 'rxjs/operators';
+import { replaceLast } from './replace-last';
+import * as i0 from "@angular/core";
+import * as i1 from "@vendure/admin-ui/core";
+/**
+ * Handles the logic for making the API calls to perform CRUD operations on a Product and its related
+ * entities. This logic was extracted out of the component because it became too large and hard to follow.
+ */
+export class ProductDetailService {
+    constructor(dataService) {
+        this.dataService = dataService;
+    }
+    getFacets() {
+        return this.dataService.facet.getAllFacets().mapSingle(data => data.facets.items);
+    }
+    getTaxCategories() {
+        return this.dataService.settings
+            .getTaxCategories()
+            .mapSingle(data => data.taxCategories)
+            .pipe(shareReplay(1));
+    }
+    createProductWithVariants(input, createVariantsConfig, languageCode) {
+        const createProduct$ = this.dataService.product.createProduct(input);
+        const nonEmptyOptionGroups = createVariantsConfig.groups.filter(g => 0 < g.values.length);
+        const createOptionGroups$ = this.createProductOptionGroups(nonEmptyOptionGroups, languageCode);
+        return forkJoin(createProduct$, createOptionGroups$).pipe(mergeMap(([{ createProduct }, optionGroups]) => {
+            const addOptionsToProduct$ = optionGroups.length
+                ? forkJoin(optionGroups.map(optionGroup => {
+                    return this.dataService.product.addOptionGroupToProduct({
+                        productId: createProduct.id,
+                        optionGroupId: optionGroup.id,
+                    });
+                }))
+                : of([]);
+            return addOptionsToProduct$.pipe(map(() => {
+                return { createProduct, optionGroups };
+            }));
+        }), mergeMap(({ createProduct, optionGroups }) => {
+            const variants = createVariantsConfig.variants.map(v => {
+                const optionIds = optionGroups.length
+                    ? v.optionValues.map((optionName, index) => {
+                        const option = optionGroups[index].options.find(o => o.name === optionName);
+                        if (!option) {
+                            throw new Error(`Could not find a matching ProductOption "${optionName}" when creating variant`);
+                        }
+                        return option.id;
+                    })
+                    : [];
+                return {
+                    ...v,
+                    optionIds,
+                };
+            });
+            const options = optionGroups.map(og => og.options).reduce((flat, o) => [...flat, ...o], []);
+            return this.createProductVariants(createProduct, variants, options, languageCode);
+        }));
+    }
+    createProductOptionGroups(groups, languageCode) {
+        return groups.length
+            ? forkJoin(groups.map(c => {
+                return this.dataService.product
+                    .createProductOptionGroups({
+                    code: normalizeString(c.name, '-'),
+                    translations: [{ languageCode, name: c.name }],
+                    options: c.values.map(v => ({
+                        code: normalizeString(v, '-'),
+                        translations: [{ languageCode, name: v }],
+                    })),
+                })
+                    .pipe(map(data => data.createProductOptionGroup));
+            }))
+            : of([]);
+    }
+    createProductVariants(product, variantData, options, languageCode) {
+        const variants = variantData.map(v => {
+            const name = options.length
+                ? `${product.name} ${v.optionIds
+                    .map(id => options.find(o => o.id === id))
+                    .filter(notNullOrUndefined)
+                    .map(o => o.name)
+                    .join(' ')}`
+                : product.name;
+            return {
+                productId: product.id,
+                price: v.price,
+                sku: v.sku,
+                stockOnHand: v.stock,
+                translations: [
+                    {
+                        languageCode,
+                        name,
+                    },
+                ],
+                optionIds: v.optionIds,
+            };
+        });
+        return this.dataService.product.createProductVariants(variants).pipe(map(({ createProductVariants }) => ({
+            createProductVariants,
+            productId: product.id,
+        })));
+    }
+    updateProduct(updateOptions) {
+        const { product, languageCode, autoUpdate, productInput, variantsInput } = updateOptions;
+        const updateOperations = [];
+        const updateVariantsInput = variantsInput || [];
+        const variants$ = autoUpdate
+            ? this.dataService.product
+                .getProductVariants({}, product.id)
+                .mapSingle(({ productVariants }) => productVariants.items)
+            : of([]);
+        return variants$.pipe(mergeMap(variants => {
+            if (productInput) {
+                updateOperations.push(this.dataService.product.updateProduct(productInput));
+                const productOldName = findTranslation(product, languageCode)?.name ?? '';
+                const productNewName = findTranslation(productInput, languageCode)?.name;
+                if (productNewName && productOldName !== productNewName && autoUpdate) {
+                    for (const variant of variants) {
+                        const currentVariantName = findTranslation(variant, languageCode)?.name || '';
+                        let variantInput;
+                        const existingVariantInput = updateVariantsInput.find(i => i.id === variant.id);
+                        if (existingVariantInput) {
+                            variantInput = existingVariantInput;
+                        }
+                        else {
+                            variantInput = {
+                                id: variant.id,
+                                translations: [{ languageCode, name: currentVariantName }],
+                            };
+                            updateVariantsInput.push(variantInput);
+                        }
+                        const variantTranslation = findTranslation(variantInput, languageCode);
+                        if (variantTranslation) {
+                            if (variantTranslation.name) {
+                                variantTranslation.name = replaceLast(variantTranslation.name, productOldName, productNewName);
+                            }
+                            else {
+                                // The variant translation was falsy, which occurs
+                                // when defining the product name for a new translation
+                                // language that had not yet been defined.
+                                variantTranslation.name = [
+                                    productNewName,
+                                    ...variant.options.map(o => o.name),
+                                ].join(' ');
+                            }
+                        }
+                    }
+                }
+            }
+            if (updateVariantsInput.length) {
+                updateOperations.push(this.dataService.product.updateProductVariants(updateVariantsInput));
+            }
+            return forkJoin(updateOperations);
+        }));
+    }
+    updateProductOption(input, product, languageCode) {
+        const variants$ = input.autoUpdate
+            ? this.dataService.product
+                .getProductVariants({}, product.id)
+                .mapSingle(({ productVariants }) => productVariants.items)
+            : of([]);
+        return variants$.pipe(mergeMap(variants => {
+            let updateProductVariantNames$ = of([]);
+            if (input.autoUpdate) {
+                // Update any ProductVariants' names which include the option name
+                let oldOptionName;
+                const newOptionName = findTranslation(input, languageCode)?.name;
+                if (!newOptionName) {
+                    updateProductVariantNames$ = of([]);
+                }
+                const variantsToUpdate = [];
+                for (const variant of variants) {
+                    if (variant.options.map(o => o.id).includes(input.id)) {
+                        if (!oldOptionName) {
+                            oldOptionName = findTranslation(variant.options.find(o => o.id === input.id), languageCode)?.name;
+                        }
+                        const variantName = findTranslation(variant, languageCode)?.name || '';
+                        if (oldOptionName && newOptionName && variantName.includes(oldOptionName)) {
+                            variantsToUpdate.push({
+                                id: variant.id,
+                                translations: [
+                                    {
+                                        languageCode,
+                                        name: replaceLast(variantName, oldOptionName, newOptionName),
+                                    },
+                                ],
+                            });
+                        }
+                    }
+                }
+                if (variantsToUpdate.length) {
+                    updateProductVariantNames$ =
+                        this.dataService.product.updateProductVariants(variantsToUpdate);
+                }
+            }
+            return this.dataService.product
+                .updateProductOption(input)
+                .pipe(mergeMap(() => updateProductVariantNames$));
+        }));
+    }
+    deleteProductVariant(id, productId) {
+        return this.dataService.product.deleteProductVariant(id).pipe(switchMap(result => {
+            if (result.deleteProductVariant.result === DeletionResult.DELETED) {
+                return this.dataService.product.getProduct(productId).single$;
+            }
+            else {
+                return throwError(result.deleteProductVariant.message);
+            }
+        }));
+    }
+}
+ProductDetailService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductDetailService, deps: [{ token: i1.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductDetailService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductDetailService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductDetailService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-detail.service.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/providers/product-detail/product-detail.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n    CreateProductInput,\r\n    CreateProductVariantInput,\r\n    DataService,\r\n    DeletionResult,\r\n    FacetWithValuesFragment,\r\n    findTranslation,\r\n    GetProductWithVariantsQuery,\r\n    LanguageCode,\r\n    UpdateProductInput,\r\n    UpdateProductMutation,\r\n    UpdateProductOptionInput,\r\n    UpdateProductVariantInput,\r\n    UpdateProductVariantsMutation,\r\n} from '@vendure/admin-ui/core';\r\nimport { normalizeString } from '@vendure/common/lib/normalize-string';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { forkJoin, Observable, of, throwError } from 'rxjs';\r\nimport { map, mergeMap, shareReplay, switchMap } from 'rxjs/operators';\r\n\r\nimport { CreateProductVariantsConfig } from '../../components/generate-product-variants/generate-product-variants.component';\r\n\r\nimport { replaceLast } from './replace-last';\r\n\r\n/**\r\n * Handles the logic for making the API calls to perform CRUD operations on a Product and its related\r\n * entities. This logic was extracted out of the component because it became too large and hard to follow.\r\n */\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class ProductDetailService {\r\n    constructor(private dataService: DataService) {}\r\n\r\n    getFacets(): Observable<FacetWithValuesFragment[]> {\r\n        return this.dataService.facet.getAllFacets().mapSingle(data => data.facets.items);\r\n    }\r\n\r\n    getTaxCategories() {\r\n        return this.dataService.settings\r\n            .getTaxCategories()\r\n            .mapSingle(data => data.taxCategories)\r\n            .pipe(shareReplay(1));\r\n    }\r\n\r\n    createProductWithVariants(\r\n        input: CreateProductInput,\r\n        createVariantsConfig: CreateProductVariantsConfig,\r\n        languageCode: LanguageCode,\r\n    ) {\r\n        const createProduct$ = this.dataService.product.createProduct(input);\r\n        const nonEmptyOptionGroups = createVariantsConfig.groups.filter(g => 0 < g.values.length);\r\n        const createOptionGroups$ = this.createProductOptionGroups(nonEmptyOptionGroups, languageCode);\r\n\r\n        return forkJoin(createProduct$, createOptionGroups$).pipe(\r\n            mergeMap(([{ createProduct }, optionGroups]) => {\r\n                const addOptionsToProduct$ = optionGroups.length\r\n                    ? forkJoin(\r\n                          optionGroups.map(optionGroup => {\r\n                              return this.dataService.product.addOptionGroupToProduct({\r\n                                  productId: createProduct.id,\r\n                                  optionGroupId: optionGroup.id,\r\n                              });\r\n                          }),\r\n                      )\r\n                    : of([]);\r\n                return addOptionsToProduct$.pipe(\r\n                    map(() => {\r\n                        return { createProduct, optionGroups };\r\n                    }),\r\n                );\r\n            }),\r\n            mergeMap(({ createProduct, optionGroups }) => {\r\n                const variants = createVariantsConfig.variants.map(v => {\r\n                    const optionIds = optionGroups.length\r\n                        ? v.optionValues.map((optionName, index) => {\r\n                              const option = optionGroups[index].options.find(o => o.name === optionName);\r\n                              if (!option) {\r\n                                  throw new Error(\r\n                                      `Could not find a matching ProductOption \"${optionName}\" when creating variant`,\r\n                                  );\r\n                              }\r\n                              return option.id;\r\n                          })\r\n                        : [];\r\n                    return {\r\n                        ...v,\r\n                        optionIds,\r\n                    };\r\n                });\r\n                const options = optionGroups.map(og => og.options).reduce((flat, o) => [...flat, ...o], []);\r\n                return this.createProductVariants(createProduct, variants, options, languageCode);\r\n            }),\r\n        );\r\n    }\r\n\r\n    createProductOptionGroups(groups: Array<{ name: string; values: string[] }>, languageCode: LanguageCode) {\r\n        return groups.length\r\n            ? forkJoin(\r\n                  groups.map(c => {\r\n                      return this.dataService.product\r\n                          .createProductOptionGroups({\r\n                              code: normalizeString(c.name, '-'),\r\n                              translations: [{ languageCode, name: c.name }],\r\n                              options: c.values.map(v => ({\r\n                                  code: normalizeString(v, '-'),\r\n                                  translations: [{ languageCode, name: v }],\r\n                              })),\r\n                          })\r\n                          .pipe(map(data => data.createProductOptionGroup));\r\n                  }),\r\n              )\r\n            : of([]);\r\n    }\r\n\r\n    createProductVariants(\r\n        product: { name: string; id: string },\r\n        variantData: Array<{ price: number; sku: string; stock: number; optionIds: string[] }>,\r\n        options: Array<{ id: string; name: string }>,\r\n        languageCode: LanguageCode,\r\n    ) {\r\n        const variants: CreateProductVariantInput[] = variantData.map(v => {\r\n            const name = options.length\r\n                ? `${product.name} ${v.optionIds\r\n                      .map(id => options.find(o => o.id === id))\r\n                      .filter(notNullOrUndefined)\r\n                      .map(o => o.name)\r\n                      .join(' ')}`\r\n                : product.name;\r\n            return {\r\n                productId: product.id,\r\n                price: v.price,\r\n                sku: v.sku,\r\n                stockOnHand: v.stock,\r\n                translations: [\r\n                    {\r\n                        languageCode,\r\n                        name,\r\n                    },\r\n                ],\r\n                optionIds: v.optionIds,\r\n            };\r\n        });\r\n        return this.dataService.product.createProductVariants(variants).pipe(\r\n            map(({ createProductVariants }) => ({\r\n                createProductVariants,\r\n                productId: product.id,\r\n            })),\r\n        );\r\n    }\r\n\r\n    updateProduct(updateOptions: {\r\n        product: NonNullable<GetProductWithVariantsQuery['product']>;\r\n        languageCode: LanguageCode;\r\n        autoUpdate: boolean;\r\n        productInput?: UpdateProductInput;\r\n        variantsInput?: UpdateProductVariantInput[];\r\n    }) {\r\n        const { product, languageCode, autoUpdate, productInput, variantsInput } = updateOptions;\r\n        const updateOperations: Array<Observable<UpdateProductMutation | UpdateProductVariantsMutation>> = [];\r\n        const updateVariantsInput = variantsInput || [];\r\n\r\n        const variants$ = autoUpdate\r\n            ? this.dataService.product\r\n                  .getProductVariants({}, product.id)\r\n                  .mapSingle(({ productVariants }) => productVariants.items)\r\n            : of([]);\r\n\r\n        return variants$.pipe(\r\n            mergeMap(variants => {\r\n                if (productInput) {\r\n                    updateOperations.push(this.dataService.product.updateProduct(productInput));\r\n                    const productOldName = findTranslation(product, languageCode)?.name ?? '';\r\n                    const productNewName = findTranslation(productInput, languageCode)?.name;\r\n                    if (productNewName && productOldName !== productNewName && autoUpdate) {\r\n                        for (const variant of variants) {\r\n                            const currentVariantName = findTranslation(variant, languageCode)?.name || '';\r\n                            let variantInput: UpdateProductVariantInput;\r\n                            const existingVariantInput = updateVariantsInput.find(i => i.id === variant.id);\r\n                            if (existingVariantInput) {\r\n                                variantInput = existingVariantInput;\r\n                            } else {\r\n                                variantInput = {\r\n                                    id: variant.id,\r\n                                    translations: [{ languageCode, name: currentVariantName }],\r\n                                };\r\n                                updateVariantsInput.push(variantInput);\r\n                            }\r\n                            const variantTranslation = findTranslation(variantInput, languageCode);\r\n                            if (variantTranslation) {\r\n                                if (variantTranslation.name) {\r\n                                    variantTranslation.name = replaceLast(\r\n                                        variantTranslation.name,\r\n                                        productOldName,\r\n                                        productNewName,\r\n                                    );\r\n                                } else {\r\n                                    // The variant translation was falsy, which occurs\r\n                                    // when defining the product name for a new translation\r\n                                    // language that had not yet been defined.\r\n                                    variantTranslation.name = [\r\n                                        productNewName,\r\n                                        ...variant.options.map(o => o.name),\r\n                                    ].join(' ');\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                if (updateVariantsInput.length) {\r\n                    updateOperations.push(\r\n                        this.dataService.product.updateProductVariants(updateVariantsInput),\r\n                    );\r\n                }\r\n                return forkJoin(updateOperations);\r\n            }),\r\n        );\r\n    }\r\n\r\n    updateProductOption(\r\n        input: UpdateProductOptionInput & { autoUpdate: boolean },\r\n        product: NonNullable<GetProductWithVariantsQuery['product']>,\r\n        languageCode: LanguageCode,\r\n    ) {\r\n        const variants$ = input.autoUpdate\r\n            ? this.dataService.product\r\n                  .getProductVariants({}, product.id)\r\n                  .mapSingle(({ productVariants }) => productVariants.items)\r\n            : of([]);\r\n\r\n        return variants$.pipe(\r\n            mergeMap(variants => {\r\n                let updateProductVariantNames$: Observable<any> = of([]);\r\n                if (input.autoUpdate) {\r\n                    // Update any ProductVariants' names which include the option name\r\n                    let oldOptionName: string | undefined;\r\n                    const newOptionName = findTranslation(input, languageCode)?.name;\r\n                    if (!newOptionName) {\r\n                        updateProductVariantNames$ = of([]);\r\n                    }\r\n                    const variantsToUpdate: UpdateProductVariantInput[] = [];\r\n                    for (const variant of variants) {\r\n                        if (variant.options.map(o => o.id).includes(input.id)) {\r\n                            if (!oldOptionName) {\r\n                                oldOptionName = findTranslation(\r\n                                    variant.options.find(o => o.id === input.id),\r\n                                    languageCode,\r\n                                )?.name;\r\n                            }\r\n                            const variantName = findTranslation(variant, languageCode)?.name || '';\r\n                            if (oldOptionName && newOptionName && variantName.includes(oldOptionName)) {\r\n                                variantsToUpdate.push({\r\n                                    id: variant.id,\r\n                                    translations: [\r\n                                        {\r\n                                            languageCode,\r\n                                            name: replaceLast(variantName, oldOptionName, newOptionName),\r\n                                        },\r\n                                    ],\r\n                                });\r\n                            }\r\n                        }\r\n                    }\r\n                    if (variantsToUpdate.length) {\r\n                        updateProductVariantNames$ =\r\n                            this.dataService.product.updateProductVariants(variantsToUpdate);\r\n                    }\r\n                }\r\n                return this.dataService.product\r\n                    .updateProductOption(input)\r\n                    .pipe(mergeMap(() => updateProductVariantNames$));\r\n            }),\r\n        );\r\n    }\r\n\r\n    deleteProductVariant(id: string, productId: string) {\r\n        return this.dataService.product.deleteProductVariant(id).pipe(\r\n            switchMap(result => {\r\n                if (result.deleteProductVariant.result === DeletionResult.DELETED) {\r\n                    return this.dataService.product.getProduct(productId).single$;\r\n                } else {\r\n                    return throwError(result.deleteProductVariant.message);\r\n                }\r\n            }),\r\n        );\r\n    }\r\n}\r\n"]}

package/esm2020/catalog/providers/routing/asset-resolver.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { AssetType, BaseEntityResolver } from '@vendure/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@vendure/admin-ui/core";
+export class AssetResolver extends BaseEntityResolver {
+    constructor(router, dataService) {
+        super(router, {
+            __typename: 'Asset',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            name: '',
+            type: AssetType.IMAGE,
+            fileSize: 0,
+            mimeType: '',
+            width: 0,
+            height: 0,
+            source: '',
+            preview: '',
+            focalPoint: null,
+        }, id => dataService.product.getAsset(id).mapStream(data => data.asset));
+    }
+}
+AssetResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AssetResolver, deps: [{ token: i1.Router }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+AssetResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AssetResolver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AssetResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/catalog/providers/routing/collection-resolver.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { BaseEntityResolver, getDefaultUiLanguage, } from '@vendure/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@vendure/admin-ui/core";
+export class CollectionResolver extends BaseEntityResolver {
+    constructor(router, dataService) {
+        super(router, {
+            __typename: 'Collection',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            languageCode: getDefaultUiLanguage(),
+            name: '',
+            slug: '',
+            isPrivate: false,
+            description: '',
+            featuredAsset: null,
+            assets: [],
+            translations: [],
+            filters: [],
+            parent: {},
+            children: null,
+        }, id => dataService.collection.getCollection(id).mapStream(data => data.collection));
+    }
+}
+CollectionResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CollectionResolver, deps: [{ token: i1.Router }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+CollectionResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CollectionResolver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CollectionResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/catalog/providers/routing/facet-resolver.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { BaseEntityResolver, getDefaultUiLanguage, } from '@vendure/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@vendure/admin-ui/core";
+export class FacetResolver extends BaseEntityResolver {
+    constructor(router, dataService) {
+        super(router, {
+            __typename: 'Facet',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            isPrivate: false,
+            languageCode: getDefaultUiLanguage(),
+            name: '',
+            code: '',
+            translations: [],
+            values: [],
+        }, id => dataService.facet.getFacet(id).mapStream(data => data.facet));
+    }
+}
+FacetResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FacetResolver, deps: [{ token: i1.Router }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+FacetResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FacetResolver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: FacetResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/catalog/providers/routing/product-resolver.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { BaseEntityResolver, getDefaultUiLanguage, } from '@vendure/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@vendure/admin-ui/core";
+import * as i2 from "@angular/router";
+export class ProductResolver extends BaseEntityResolver {
+    constructor(dataService, router) {
+        super(router, {
+            __typename: 'Product',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            enabled: true,
+            languageCode: getDefaultUiLanguage(),
+            name: '',
+            slug: '',
+            featuredAsset: null,
+            assets: [],
+            description: '',
+            translations: [],
+            optionGroups: [],
+            facetValues: [],
+            variantList: { items: [], totalItems: 0 },
+            channels: [],
+        }, id => dataService.product
+            .getProduct(id, { take: 10 })
+            .refetchOnChannelChange()
+            .mapStream(data => data.product));
+    }
+}
+ProductResolver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductResolver, deps: [{ token: i1.DataService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductResolver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductResolver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProductResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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