@deenruv/admin-ui 1.0.0

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

@@ -0,0 +1,64 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { createUpdatedTranslatable, } from '@deenruv/admin-ui/core';
+import { normalizeString } from '@deenruv/common/lib/normalize-string';
+import * as i0 from "@angular/core";
+import * as i1 from "@clr/angular";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@deenruv/admin-ui/core";
+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 UntypedFormGroup({});
+        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 UntypedFormControl(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, '-');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UpdateProductOptionDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: UpdateProductOptionDialogComponent, selector: "vdr-update-product-option-dialog", ngImport: i0, template: "<ng-template vdrDialogTitle>{{ 'catalog.update-product-option' | translate }}</ng-template>\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\n    <input\n        id=\"name\"\n        type=\"text\"\n        #nameInput=\"ngModel\"\n        [(ngModel)]=\"name\"\n        required\n        (input)=\"updateCode($event.target.value)\"\n    />\n</vdr-form-field>\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\n</vdr-form-field>\n<clr-checkbox-wrapper>\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\n</clr-checkbox-wrapper>\n<section *ngIf=\"customFields.length\">\n    <label>{{ 'common.custom-fields' | translate }}</label>\n    <vdr-tabbed-custom-fields\n        entityName=\"ProductOption\"\n        [customFields]=\"customFields\"\n        [customFieldsFormGroup]=\"customFieldsForm\"\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\n    ></vdr-tabbed-custom-fields>\n</section>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button\n        type=\"submit\"\n        (click)=\"update()\"\n        [disabled]=\"\n            nameInput.invalid ||\n            codeInput.invalid ||\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\n        \"\n        class=\"btn btn-primary\"\n    >\n        {{ 'catalog.update-product-option' | translate }}\n    </button>\n</ng-template>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.ClrLabel, selector: "label", inputs: ["id", "for"] }, { kind: "directive", type: i1.ClrCheckbox, selector: "[clrCheckbox],[clrToggle]" }, { kind: "component", type: i1.ClrCheckboxWrapper, selector: "clr-checkbox-wrapper,clr-toggle-wrapper" }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", 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]" }, { kind: "directive", type: i3.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i3.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.FormFieldComponent, selector: "vdr-form-field", inputs: ["label", "for", "tooltip", "errors", "readOnlyToggle"], outputs: ["readOnlyToggleChange"] }, { kind: "directive", type: i4.FormFieldControlDirective, selector: "input, textarea, select, vdr-currency-input" }, { kind: "directive", type: i4.DialogButtonsDirective, selector: "[vdrDialogButtons]" }, { kind: "directive", type: i4.DialogTitleDirective, selector: "[vdrDialogTitle]" }, { kind: "component", type: i4.TabbedCustomFieldsComponent, selector: "vdr-tabbed-custom-fields", inputs: ["entityName", "customFields", "customFieldsFormGroup", "readonly", "compact", "showLabel"] }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "pipe", type: i4.HasPermissionPipe, name: "hasPermission" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", 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>\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\n    <input\n        id=\"name\"\n        type=\"text\"\n        #nameInput=\"ngModel\"\n        [(ngModel)]=\"name\"\n        required\n        (input)=\"updateCode($event.target.value)\"\n    />\n</vdr-form-field>\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\n</vdr-form-field>\n<clr-checkbox-wrapper>\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\n</clr-checkbox-wrapper>\n<section *ngIf=\"customFields.length\">\n    <label>{{ 'common.custom-fields' | translate }}</label>\n    <vdr-tabbed-custom-fields\n        entityName=\"ProductOption\"\n        [customFields]=\"customFields\"\n        [customFieldsFormGroup]=\"customFieldsForm\"\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\n    ></vdr-tabbed-custom-fields>\n</section>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button\n        type=\"submit\"\n        (click)=\"update()\"\n        [disabled]=\"\n            nameInput.invalid ||\n            codeInput.invalid ||\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\n        \"\n        class=\"btn btn-primary\"\n    >\n        {{ 'catalog.update-product-option' | translate }}\n    </button>\n</ng-template>\n" }]
+        }] });
+//# 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,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAKH,yBAAyB,GAE5B,MAAM,wBAAwB,CAAC;AAEhC,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,gBAAgB,CAAC,EAAE,CAAC,CAAC;QACjD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,MAAM,oBAAoB,GACtB,CAAC,kBAAkB,IAAK,kBAA0B,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YAE3E,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACvC,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,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;YACnF,CAAC;QACL,CAAC;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,CAAC;YACrD,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAChD,CAAC;IACL,CAAC;+GA9DQ,kCAAkC;mGAAlC,kCAAkC,wECnB/C,yrDA2CA;;4FDxBa,kCAAkC;kBAN9C,SAAS;+BACI,kCAAkC,mBAG3B,uBAAuB,CAAC,MAAM","sourcesContent":["import { ChangeDetectionStrategy, Component, OnInit } from '@angular/core';\nimport { UntypedFormControl, UntypedFormGroup } from '@angular/forms';\nimport {\n    CustomFieldConfig,\n    LanguageCode,\n    ProductVariantFragment,\n    UpdateProductOptionInput,\n    createUpdatedTranslatable,\n    Dialog,\n} from '@deenruv/admin-ui/core';\n\nimport { normalizeString } from '@deenruv/common/lib/normalize-string';\n\n@Component({\n    selector: 'vdr-update-product-option-dialog',\n    templateUrl: './update-product-option-dialog.component.html',\n    styleUrls: ['./update-product-option-dialog.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class UpdateProductOptionDialogComponent\n    implements Dialog<UpdateProductOptionInput & { autoUpdate: boolean }>, OnInit\n{\n    resolveWith: (result?: UpdateProductOptionInput & { autoUpdate: boolean }) => void;\n    updateVariantName = true;\n    // Provided by caller\n    productOption: ProductVariantFragment['options'][number];\n    activeLanguage: LanguageCode;\n    name: string;\n    code: string;\n    customFields: CustomFieldConfig[];\n    codeInputTouched = false;\n    customFieldsForm: UntypedFormGroup;\n\n    ngOnInit(): void {\n        const currentTranslation = this.productOption.translations.find(\n            t => t.languageCode === this.activeLanguage,\n        );\n        this.name = currentTranslation?.name ?? '';\n        this.code = this.productOption.code;\n        this.customFieldsForm = new UntypedFormGroup({});\n        if (this.customFields) {\n            const cfCurrentTranslation =\n                (currentTranslation && (currentTranslation as any).customFields) || {};\n\n            for (const fieldDef of this.customFields) {\n                const key = fieldDef.name;\n                const value =\n                    fieldDef.type === 'localeString'\n                        ? cfCurrentTranslation[key]\n                        : (this.productOption as any).customFields[key];\n                this.customFieldsForm.addControl(fieldDef.name, new UntypedFormControl(value));\n            }\n        }\n    }\n\n    update() {\n        const result = createUpdatedTranslatable({\n            translatable: this.productOption,\n            languageCode: this.activeLanguage,\n            updatedFields: {\n                code: this.code,\n                name: this.name,\n                customFields: this.customFieldsForm.value,\n            },\n            customFieldConfig: this.customFields,\n            defaultTranslation: {\n                languageCode: this.activeLanguage,\n                name: '',\n            },\n        });\n        this.resolveWith({ ...result, autoUpdate: this.updateVariantName });\n    }\n\n    cancel() {\n        this.resolveWith();\n    }\n\n    updateCode(nameValue: string) {\n        if (!this.codeInputTouched && !this.productOption.code) {\n            this.code = normalizeString(nameValue, '-');\n        }\n    }\n}\n","<ng-template vdrDialogTitle>{{ 'catalog.update-product-option' | translate }}</ng-template>\n<vdr-form-field [label]=\"'catalog.option-name' | translate\" for=\"name\">\n    <input\n        id=\"name\"\n        type=\"text\"\n        #nameInput=\"ngModel\"\n        [(ngModel)]=\"name\"\n        required\n        (input)=\"updateCode($event.target.value)\"\n    />\n</vdr-form-field>\n<vdr-form-field [label]=\"'common.code' | translate\" for=\"code\">\n    <input id=\"code\" type=\"text\" #codeInput=\"ngModel\" required [(ngModel)]=\"code\" pattern=\"[a-z0-9_-]+\" />\n</vdr-form-field>\n<clr-checkbox-wrapper>\n    <input type=\"checkbox\" clrCheckbox [(ngModel)]=\"updateVariantName\" />\n    <label>{{ 'catalog.auto-update-option-variant-name' | translate }}</label>\n</clr-checkbox-wrapper>\n<section *ngIf=\"customFields.length\">\n    <label>{{ 'common.custom-fields' | translate }}</label>\n    <vdr-tabbed-custom-fields\n        entityName=\"ProductOption\"\n        [customFields]=\"customFields\"\n        [customFieldsFormGroup]=\"customFieldsForm\"\n        [readonly]=\"!(['UpdateCatalog', 'UpdateProduct'] | hasPermission)\"\n    ></vdr-tabbed-custom-fields>\n</section>\n\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn\" (click)=\"cancel()\">{{ 'common.cancel' | translate }}</button>\n    <button\n        type=\"submit\"\n        (click)=\"update()\"\n        [disabled]=\"\n            nameInput.invalid ||\n            codeInput.invalid ||\n            (nameInput.pristine && codeInput.pristine && customFieldsForm.pristine)\n        \"\n        class=\"btn btn-primary\"\n    >\n        {{ 'catalog.update-product-option' | translate }}\n    </button>\n</ng-template>\n"]}

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

@@ -0,0 +1,59 @@
+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 "@deenruv/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]) => 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);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VariantPriceDetailComponent, deps: [{ token: i1.DataService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", 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>\n<div *ngIf=\"priceIncludesTax\" class=\"value\">\n    {{ 'catalog.price-includes-tax-at' | translate: { rate: taxRate$ | async } }}\n</div>\n<div *ngIf=\"!priceIncludesTax\" class=\"value\">\n    {{\n        'catalog.price-with-tax-in-default-zone'\n            | translate: { price: grossPrice$ | async | localeCurrency: currencyCode, rate: taxRate$ | async }\n    }}\n</div>\n", styles: [":host{display:flex;flex-direction:column}.value{margin-top:3px}\n"], dependencies: [{ kind: "directive", type: i2.ClrLabel, selector: "label", inputs: ["id", "for"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "pipe", type: i1.LocaleCurrencyPipe, name: "localeCurrency" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", 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>\n<div *ngIf=\"priceIncludesTax\" class=\"value\">\n    {{ 'catalog.price-includes-tax-at' | translate: { rate: taxRate$ | async } }}\n</div>\n<div *ngIf=\"!priceIncludesTax\" class=\"value\">\n    {{\n        'catalog.price-with-tax-in-default-zone'\n            | translate: { price: grossPrice$ | async | localeCurrency: currencyCode, rate: taxRate$ | async }\n    }}\n</div>\n", styles: [":host{display:flex;flex-direction:column}.value{margin-top:3px}\n"] }]
+        }], ctorParameters: () => [{ 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/esm2022/catalog/components/variant-price-strategy-detail/variant-price-strategy-detail.component.mjs

@@ -0,0 +1,33 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@deenruv/admin-ui/core";
+import * as i3 from "@ngx-translate/core";
+export class VariantPriceStrategyDetailComponent {
+    calculatedPriceDiffersFromInputPrice() {
+        const defaultPrice = this.variant.prices.find(p => p.currencyCode === this.channelDefaultCurrencyCode) ??
+            this.variant.prices[0];
+        if (!defaultPrice) {
+            return false;
+        }
+        if (this.channelPriceIncludesTax) {
+            return this.variant.priceWithTax !== defaultPrice.price;
+        }
+        else {
+            return this.variant.price !== defaultPrice.price;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VariantPriceStrategyDetailComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: VariantPriceStrategyDetailComponent, selector: "vdr-variant-price-strategy-detail", inputs: { channelPriceIncludesTax: "channelPriceIncludesTax", variant: "variant", channelDefaultCurrencyCode: "channelDefaultCurrencyCode" }, ngImport: i0, template: "<div *ngIf=\"calculatedPriceDiffersFromInputPrice()\" class=\"price-strategy-detail\">\n    <vdr-form-item\n        [label]=\"'catalog.calculated-price' | translate\"\n        [tooltip]=\"'catalog.calculated-price-tooltip' | translate\"\n        for=\"price\"\n    >\n    </vdr-form-item>\n    <div class=\"form-grid mt-2\">\n        <vdr-form-item [label]=\"'common.price' | translate\">\n            {{ variant.price | localeCurrency : variant.currencyCode }}\n        </vdr-form-item>\n        <vdr-form-item [label]=\"'common.price-with-tax' | translate\">\n            {{ variant.priceWithTax | localeCurrency : variant.currencyCode }}\n        </vdr-form-item>\n    </div>\n</div>\n", styles: [":host{display:block}.price-strategy-detail{margin-top:calc(var(--space-unit) * 2);padding-top:calc(var(--space-unit) * 2);border-top:1px solid var(--color-weight-150)}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.FormItemComponent, selector: "vdr-form-item", inputs: ["label", "tooltip"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "pipe", type: i2.LocaleCurrencyPipe, name: "localeCurrency" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VariantPriceStrategyDetailComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-variant-price-strategy-detail', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div *ngIf=\"calculatedPriceDiffersFromInputPrice()\" class=\"price-strategy-detail\">\n    <vdr-form-item\n        [label]=\"'catalog.calculated-price' | translate\"\n        [tooltip]=\"'catalog.calculated-price-tooltip' | translate\"\n        for=\"price\"\n    >\n    </vdr-form-item>\n    <div class=\"form-grid mt-2\">\n        <vdr-form-item [label]=\"'common.price' | translate\">\n            {{ variant.price | localeCurrency : variant.currencyCode }}\n        </vdr-form-item>\n        <vdr-form-item [label]=\"'common.price-with-tax' | translate\">\n            {{ variant.priceWithTax | localeCurrency : variant.currencyCode }}\n        </vdr-form-item>\n    </div>\n</div>\n", styles: [":host{display:block}.price-strategy-detail{margin-top:calc(var(--space-unit) * 2);padding-top:calc(var(--space-unit) * 2);border-top:1px solid var(--color-weight-150)}\n"] }]
+        }], propDecorators: { channelPriceIncludesTax: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], channelDefaultCurrencyCode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/catalog/deenruv-admin-ui-catalog.mjs

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

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

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

package/esm2022/catalog/providers/product-detail/replace-last.mjs

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * Like String.prototype.replace(), but replaces the last instance
+ * rather than the first.
+ */
+export function replaceLast(target, search, replace) {
+    if (!target) {
+        return '';
+    }
+    const lastIndex = target.lastIndexOf(search);
+    if (lastIndex === -1) {
+        return target;
+    }
+    const head = target.substr(0, lastIndex);
+    const tail = target.substr(lastIndex).replace(search, replace);
+    return head + tail;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwbGFjZS1sYXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jYXRhbG9nL3NyYy9wcm92aWRlcnMvcHJvZHVjdC1kZXRhaWwvcmVwbGFjZS1sYXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFDLE1BQWlDLEVBQUUsTUFBYyxFQUFFLE9BQWU7SUFDMUYsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1YsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDO0lBQ0QsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM3QyxJQUFJLFNBQVMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ25CLE9BQU8sTUFBTSxDQUFDO0lBQ2xCLENBQUM7SUFDRCxNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUN6QyxNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDL0QsT0FBTyxJQUFJLEdBQUcsSUFBSSxDQUFDO0FBQ3ZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvblxuICogTGlrZSBTdHJpbmcucHJvdG90eXBlLnJlcGxhY2UoKSwgYnV0IHJlcGxhY2VzIHRoZSBsYXN0IGluc3RhbmNlXG4gKiByYXRoZXIgdGhhbiB0aGUgZmlyc3QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZXBsYWNlTGFzdCh0YXJnZXQ6IHN0cmluZyB8IHVuZGVmaW5lZCB8IG51bGwsIHNlYXJjaDogc3RyaW5nLCByZXBsYWNlOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIGlmICghdGFyZ2V0KSB7XG4gICAgICAgIHJldHVybiAnJztcbiAgICB9XG4gICAgY29uc3QgbGFzdEluZGV4ID0gdGFyZ2V0Lmxhc3RJbmRleE9mKHNlYXJjaCk7XG4gICAgaWYgKGxhc3RJbmRleCA9PT0gLTEpIHtcbiAgICAgICAgcmV0dXJuIHRhcmdldDtcbiAgICB9XG4gICAgY29uc3QgaGVhZCA9IHRhcmdldC5zdWJzdHIoMCwgbGFzdEluZGV4KTtcbiAgICBjb25zdCB0YWlsID0gdGFyZ2V0LnN1YnN0cihsYXN0SW5kZXgpLnJlcGxhY2Uoc2VhcmNoLCByZXBsYWNlKTtcbiAgICByZXR1cm4gaGVhZCArIHRhaWw7XG59XG4iXX0=

package/esm2022/catalog/providers/routing/product-variants-resolver.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { BaseEntityResolver } from '@deenruv/admin-ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@deenruv/admin-ui/core";
+export class ProductVariantsResolver extends BaseEntityResolver {
+    constructor(router, dataService) {
+        super(router, {
+            __typename: 'Product',
+            id: '',
+            createdAt: '',
+            updatedAt: '',
+            name: '',
+            languageCode: '',
+            optionGroups: [],
+            variants: [],
+        }, id => dataService.product.getProductVariantsOptions(id).mapStream(data => data.product));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProductVariantsResolver, deps: [{ token: i1.Router }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProductVariantsResolver, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProductVariantsResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.DataService }] });
+//# sourceMappingURL=data:application/json;base64,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