@configura/web-api 2.0.0-alpha.9 → 2.1.0-alpha.0

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -13,6 +13,12 @@ import { SelectionType, } from "../productConfiguration/CfgFeature.js";
 import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
 import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
 import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
+var AffectedLevel;
+(function (AffectedLevel) {
+    AffectedLevel[AffectedLevel["None"] = 0] = "None";
+    AffectedLevel[AffectedLevel["Initialized"] = 1] = "Initialized";
+    AffectedLevel[AffectedLevel["Set"] = 2] = "Set";
+})(AffectedLevel || (AffectedLevel = {}));
 /**
  * The Transaction is a transient object used to track all the changes made to the supplied
  * SyncGroupState as a result of a (normally) single initial event, like when opening a product
@@ -39,7 +45,7 @@ import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
 export class SyncGroupsTransaction {
     constructor(syncState, updateMode, productLoader, original, target, initial) {
         this._closed = false;
-        this.affectedSelectOneFeatures = new Set();
+        this.affectedSelectOneFeatures = new Map();
         this.affectedSelectManyOptions = new Set();
         this.affectedSelectOneSyncGroups = new Set();
         this.affectedSelectManySyncGroupsAndOptions = new Map();
@@ -104,7 +110,7 @@ export class SyncGroupsTransaction {
                 change = true;
                 switch (feature.selectionType) {
                     case SelectionType.SelectOne:
-                        this.affectedSelectOneFeatures.add(feature);
+                        this.affectedSelectOneFeatures.set(feature, AffectedLevel.Set);
                         break;
                     case SelectionType.SelectMany:
                         this.affectedSelectManyOptions.add(option);
@@ -266,14 +272,19 @@ export class SyncGroupsTransaction {
         return __awaiter(this, void 0, void 0, function* () {
             const feature = featureWithInitial.target;
             const featureDidJustComeIntoScope = featureWithInitial.initial === undefined;
-            if (this.affectedSelectOneFeatures.has(feature)) {
-                // This feature has already changed selection once for this transaction. We expect
-                // this to happen very rarely, as the algorithm should settle the selection tree
-                // further and further out. Nevertheless, this safeguard is needed to avoid infinite
-                // looping if for example the server would return the same data over and over.
+            const hasBeenAffectedLevel = this.affectedSelectOneFeatures.get(feature);
+            const syncGroupHasBeenUpdated = this.affectedSelectOneSyncGroups.has(syncCode);
+            if (hasBeenAffectedLevel === AffectedLevel.Set ||
+                (!syncGroupHasBeenUpdated && hasBeenAffectedLevel === AffectedLevel.Initialized)) {
+                // A feature can change value for two reasons:
+                // 1. The feature did just come into scope and loads from the sync group to set its "defaults"
+                // 2. The sync group has updated with a new value
+                // The rule is that in one sync group transaction the feature value is allowed to be updated
+                // once or twice. Once for initialization and once for new sync group value. But they have to
+                // happen in the right order.
                 return "recurseDown";
             }
-            if (!featureDidJustComeIntoScope && !this.affectedSelectOneSyncGroups.has(syncCode)) {
+            if (!featureDidJustComeIntoScope && !syncGroupHasBeenUpdated) {
                 return "recurseDown";
             }
             const currentSyncGroupValue = this.syncState.getForSelectOne(syncCode);
@@ -295,7 +306,7 @@ export class SyncGroupsTransaction {
             // Do not recurse further as we will change the state and so what is selected now won't be
             // selected then.
             yield feature.selectOption(optionToSelect._internal, true, ProductConfigurationBubbleMode.ToRoot);
-            this.affectedSelectOneFeatures.add(feature);
+            this.affectedSelectOneFeatures.set(feature, syncGroupHasBeenUpdated ? AffectedLevel.Set : AffectedLevel.Initialized);
             productsToValidate.add(feature.parentProduct);
             return "stop";
         });
@@ -435,7 +446,7 @@ export class SyncGroupsTransaction {
             return change;
         });
     }
-    applySelectOneFeature(feature, activeSelectionForce, featureDidJustComeIntoScope) {
+    applySelectOneFeature(feature, userInitiated, featureDidJustComeIntoScope) {
         const selectionType = feature.selectionType;
         if (selectionType !== SelectionType.SelectOne) {
             throw new Error("can only be used for selectOne");
@@ -453,7 +464,7 @@ export class SyncGroupsTransaction {
             // Options with no default are never written
             return false;
         }
-        if (activeSelectionForce) {
+        if (userInitiated) {
             // To make re-apply happen, even if it actually does not update the sync group
             this.affectedSelectOneSyncGroups.add(syncCode);
         }
@@ -464,7 +475,7 @@ export class SyncGroupsTransaction {
         // can not be set to the current sync group value, then it will set in the opposite
         // direction. Like if the sync group was empty. To avoid bouncing back and forth we will
         // need to enforce that a sync group can only be updated once per transaction
-        if (!(activeSelectionForce ||
+        if (!(userInitiated ||
             currentSyncGroupOptionCode === undefined ||
             (featureDidJustComeIntoScope &&
                 feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
@@ -486,7 +497,7 @@ export class SyncGroupsTransaction {
         }
         return change;
     }
-    applySelectManyOption(option, activeSelectionForce) {
+    applySelectManyOption(option, userInitiated) {
         const feature = option.parent;
         if (feature.selectionType !== SelectionType.SelectMany) {
             throw new Error("can only be used for selectMany");
@@ -500,14 +511,14 @@ export class SyncGroupsTransaction {
         }
         const optionSelected = option.selected;
         const currentSyncGroupValue = this.syncState.getForSelectMany(syncCode, option.code);
-        if (activeSelectionForce) {
+        if (userInitiated) {
             // To make re-apply happen, even if it actually does not update the sync group
             this.addSyncGroupAffectedForSelectMany(syncCode, option);
         }
-        // We only initialize if the option is selected or we force.
-        // activeSelectionForce = active selection by the user.
-        if (!(currentSyncGroupValue === undefined && optionSelected) &&
-            !(activeSelectionForce && currentSyncGroupValue !== optionSelected)) {
+        // We only initialize if the option has not been initiated or if it is userInitiated.
+        // userInitiated = active selection by the user.
+        if (currentSyncGroupValue !== undefined &&
+            !(userInitiated && currentSyncGroupValue !== optionSelected)) {
             return false;
         }
         this.addSyncGroupAffectedForSelectMany(syncCode, option);
@@ -529,7 +540,9 @@ export class SyncGroupsTransaction {
 }
 function getAdditionalProducts(product) {
     const initial = product.initial;
-    return product.target.additionalProducts.map((childTarget) => {
+    return product.target.additionalProducts
+        .filter((p) => p.selected)
+        .map((childTarget) => {
         const refKey = childTarget.refKey;
         const childInitial = initial === null || initial === void 0 ? void 0 : initial.additionalProducts.find((p) => refKey === p.refKey);
         return {
@@ -558,8 +571,8 @@ function getOptions(feature) {
 }
 function pairFeatures(targets, initials) {
     return targets.map((childTarget) => {
-        const key = childTarget.key;
-        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => key === f.key);
+        const code = childTarget.code;
+        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => code === f.code);
         return {
             target: childTarget._internal,
             initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,

package/dist/tasks/TaskHandler.d.ts

@@ -1,5 +1,5 @@
 import { Observable, SingleArgCallback } from "@configura/web-utilities";
-import { CatalogueAPI, DtoAdditionalProductConfiguration, DtoExportStatus, DtoExportStatusStatus, DtoProductParamsWithLang, DtoRenderStatus, DtoRenderStatusStatus, DtoTargetCameraArgs } from "../CatalogueAPI.js";
+import { CatalogueAPI, DtoAdditionalProductConfiguration, DtoExportStatus, DtoExportStatusStatus, DtoProductParamsWithCidAndLang, DtoRenderStatus, DtoRenderStatusStatus, DtoTargetCameraArgs } from "../CatalogueAPI.js";
 import { CfgProduct } from "../CfgProduct.js";
 import { RenderOrExportFormat } from "./formats.js";
 export declare type TasksChangeNotification = {
@@ -51,7 +51,7 @@ export declare abstract class Task<F extends RenderOrExportFormat> {
     protected constructor(taskHandler: _TaskHandlerInternal, format: F, product: CfgProduct, getPreviewUrl: (() => Promise<string>) | undefined);
     protected abstract postInit(): Promise<DtoRenderStatus | DtoExportStatus>;
     protected abstract pollStatus(): Promise<DtoRenderStatus | DtoExportStatus>;
-    protected _productParams: DtoProductParamsWithLang;
+    protected _productParams: DtoProductParamsWithCidAndLang;
     protected _apiSelection: DtoAdditionalProductConfiguration;
     private _status;
     private _uuid;

package/dist/tasks/TaskHandler.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { augmentErrorMessage, Observable } from "@configura/web-utilities";
 import { dtoExportFormatNames, dtoRenderFormatNames, } from "../CatalogueAPI.js";
+import { convertDtoProductConfToV1 } from "../utilitiesConfiguration.js";
 import { isExportFormat, isRenderFormat } from "./formats.js";
 export class _TaskHandlerInternal {
     constructor(api) {
@@ -175,7 +176,7 @@ export class Task {
             this.taskHandler.removeTask(this);
         };
         this._productParams = product.prodParams;
-        this._apiSelection = product.getApiSelection();
+        this._apiSelection = convertDtoProductConfToV1(product.getDtoConf());
         if (getPreviewUrl !== undefined) {
             void getPreviewUrl().then((dataUrl) => {
                 this._previewUrl = dataUrl;

package/dist/tests/testData/dummyProductForTest.d.ts

@@ -1,5 +1,5 @@
-import { DtoCatalogueParamsWithLang } from "../../CatalogueAPI.js";
+import { DtoCatalogueParamsWithCidAndLang } from "../../CatalogueAPI.js";
 import { CfgProduct } from "../../CfgProduct.js";
-export declare const dummyCatId: DtoCatalogueParamsWithLang;
+export declare const dummyCatId: DtoCatalogueParamsWithCidAndLang;
 export declare const getDummyCfgProduct: () => Promise<CfgProduct>;
 //# sourceMappingURL=dummyProductForTest.d.ts.map

package/dist/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.js

@@ -222,17 +222,20 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
         getProduct: getTestProduct,
         postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
             const productData = (yield getTestProduct(params)).productData;
-            productData.partsData.selOptions = [
-                {
-                    code: "!~!",
-                    next: {
-                        [letterOptionCodeC]: {
-                            code: letterOptionCodeC,
+            const partNumber = params.partNumber;
+            if (partNumber !== "D") {
+                productData.partsData.selOptions = [
+                    {
+                        code: "!~!",
+                        next: {
+                            [letterOptionCodeC]: {
+                                code: letterOptionCodeC,
+                            },
                         },
                     },
-                },
-            ];
-            if (params.partNumber === "A") {
+                ];
+            }
+            if (partNumber === "A") {
                 productData.partsData.selOptions.push({
                     code: "!~!",
                     next: {
@@ -252,8 +255,10 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
             }
             const validateResponse = {
                 uuid: "",
+                unit: "m",
                 validated: true,
                 productData,
+                features: [],
             };
             collect.pushNotification(`Validate ${params.enterprise} ${params.prdCat} ${params.prdCatVersion} ${params.priceList} ${params.vendor} ${params.partNumber}`);
             return validateResponse;

package/dist/tests/testData/testDataCachedGetProduct.js

@@ -171,8 +171,10 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
             ];
             const validateResponse = {
                 uuid: "",
+                unit: "m",
                 validated: true,
                 productData,
+                features: [],
             };
             return validateResponse;
         }),

package/dist/tests/testData/testDataCachedPostValidate.js

@@ -171,8 +171,10 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
             const productData = (yield getProduct(params)).productData;
             const validateResponse = {
                 uuid: "",
+                unit: "m",
                 validated: true,
                 productData,
+                features: [],
             };
             validateCounter.count++;
             return validateResponse;

package/dist/tests/testData/testDataProductAggregatedPrice.js

@@ -169,13 +169,15 @@ export const cfgProductPriceTest = (testFunc, featureOption) => __awaiter(void 0
         getProduct: getTestProduct,
         postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
             const productData = (yield getTestProduct(params)).productData;
-            if (featureOption !== undefined) {
+            if (featureOption !== undefined && params.partNumber === "A") {
                 productData.partsData.selOptions = getSelOptions(featureOption);
             }
             const validateResponse = {
                 uuid: "",
+                unit: "m",
                 validated: true,
                 productData,
+                features: [],
             };
             return validateResponse;
         }),

package/dist/tests/testData/testDataUpcharge.js

@@ -97,8 +97,10 @@ export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0
             const productData = (yield getProduct(params)).productData;
             const validateResponse = {
                 uuid: "",
+                unit: "m",
                 validated: true,
                 productData,
+                features: [],
             };
             return validateResponse;
         }),

package/dist/utilitiesCatalogueData.d.ts

@@ -1,12 +1,12 @@
-import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithLang, DtoCatalogueParamsWithoutCid, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParams, DtoProductParamsWithLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
+import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithCid, DtoCatalogueParamsWithCidAndLang, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParamsWithCid, DtoProductParamsWithCidAndLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
 /**
  * Makes a string from the params which can be used as a key in for example React. Language is not respected.
  */
-export declare const makeCatalogueKey: (cat: DtoCatalogueParams) => string;
+export declare const makeCatalogueKey: (cat: DtoCatalogueParamsWithCid) => string;
 /**
  * Makes a string from the params which can be used as a key in for example React. Language is not respected.
  */
-export declare const makeProductKey: (prod: DtoProductParams) => string;
+export declare const makeProductKey: (prod: DtoProductParamsWithCid) => string;
 /**
  * Makes a string from selected options, can be used as a key for a selection.
  */
@@ -18,6 +18,11 @@ export declare type CfgProductData = Omit<Omit<DtoProductData, "models">, "parts
         selOptions: DtoSelectedOption[];
     };
 };
+/**
+ * Deep compare. Uses the JSON.stringify method for comparison
+ * @returns true if equal. Key and array order is respected.
+ */
+export declare function compareCfgProductData(pd1: CfgProductData, pd2: CfgProductData): boolean;
 export declare type CfgProductResponse = Omit<DtoProductResponse, "productData"> & {
     productData: CfgProductData;
 };
@@ -27,17 +32,17 @@ export declare type CfgValidateResponse = Omit<DtoValidateResponse, "productData
 };
 export declare function isModel(arg: unknown): arg is DtoModel;
 /** Replace empty strings with "-" for compatibility with the API. */
-export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParamsWithoutCid>(catId: T): T;
+export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParams>(catId: T): T;
 export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: DtoPrices | undefined): number | undefined;
 export declare function comparePricesObjects(prices1: DtoPrices | undefined, prices2: DtoPrices | undefined): boolean;
-export declare const decodeCatalogueParams: <T extends DtoCatalogueParamsWithoutCid>(params: T) => T;
-export declare const decodeProductParams: <T extends DtoProductParams>(params: T) => T;
-export declare function isSameCatalogueParams(left: DtoCatalogueParamsWithoutCid, right: DtoCatalogueParamsWithoutCid): boolean;
+export declare const decodeCatalogueParams: <T extends DtoCatalogueParams>(params: T) => T;
+export declare const decodeProductParams: <T extends DtoProductParamsWithCid>(params: T) => T;
+export declare function isSameCatalogueParams(left: DtoCatalogueParams, right: DtoCatalogueParams): boolean;
 export declare function isSameVector(left: DtoVector, right: DtoVector): boolean;
 export declare function isSameOrientation(left: DtoOrientation, right: DtoOrientation): boolean;
 export declare function isSameAnchor(left: DtoMeasureParam, right: DtoMeasureParam): boolean;
 export declare function isSameTransform(left: DtoTransform, right: DtoTransform): boolean;
 export declare function isSameProductRef(left: DtoAdditionalProductRef, right: DtoAdditionalProductRef): boolean;
-export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithLang, right: DtoCatalogueParamsWithLang) => boolean;
-export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithLang, right: DtoProductParamsWithLang) => boolean;
+export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithCidAndLang, right: DtoCatalogueParamsWithCidAndLang) => boolean;
+export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithCidAndLang, right: DtoProductParamsWithCidAndLang) => boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map

package/dist/utilitiesCatalogueData.js

@@ -25,6 +25,13 @@ export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
     p += "_}";
     return p;
 }, "");
+/**
+ * Deep compare. Uses the JSON.stringify method for comparison
+ * @returns true if equal. Key and array order is respected.
+ */
+export function compareCfgProductData(pd1, pd2) {
+    return JSON.stringify(pd1) === JSON.stringify(pd2);
+}
 export function isModel(arg) {
     return typeof arg === "object" && arg !== null && "cid" in arg && "uri" in arg;
 }

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,10 +1,10 @@
-import { DtoCatalogueParams, DtoCataloguePermission } from "./CatalogueAPI.js";
+import { DtoCatalogueParamsWithCid, DtoCataloguePermission } from "./CatalogueAPI.js";
 interface CataloguePermissionByEnterpriseKey {
     [key: string]: DtoCataloguePermission[];
 }
 export declare const groupAndSortCataloguePermissions: (cataloguePermissions: DtoCataloguePermission[]) => CataloguePermissionByEnterpriseKey;
 export declare const isParamSet: (param: string | undefined) => boolean;
-export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParams>) => (perm: DtoCataloguePermission) => boolean;
+export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParamsWithCid>) => (perm: DtoCataloguePermission) => boolean;
 /**
  * Sometimes you will want to use the latest available prdCatVersion. This method will
  * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
@@ -25,7 +25,7 @@ export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: Dto
  * @param auth
  * @param params
  */
-export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalogueParams, cataloguePermissions: DtoCataloguePermission[]) => string;
+export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalogueParamsWithCid, cataloguePermissions: DtoCataloguePermission[]) => string;
 /**
  * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
  * This method will, if the prdCatVersion is not set, fetch the highest available from the
@@ -34,6 +34,6 @@ export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalo
  * @param auth
  * @param params
  */
-export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParams>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
+export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParamsWithCid>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
 export {};
 //# sourceMappingURL=utilitiesCataloguePermission.d.ts.map

package/dist/utilitiesConfiguration.d.ts

@@ -0,0 +1,29 @@
+import { DtoAdditionalProductConf, DtoAdditionalProductConfiguration, DtoFeatureConf, DtoProductConf, DtoSelectedOption } from "./CatalogueAPI.js";
+/**
+ * @param ExtendedData   Extra data, i.e. units and groupCodes
+ * @param ProductParams  What Product the conf is for, and the same for any Additional Products.
+ * @param SyncGroupState The current sync group state
+ */
+export declare enum CfgProdConfParts {
+    NoExtra = 0,
+    ExtendedData = 1,
+    ProdParams = 2,
+    SyncGroupState = 4
+}
+/** Is the newer version of product configuration */
+export declare const isProductConf: (value: DtoAdditionalProductConfiguration | DtoProductConf) => value is DtoAdditionalProductConf;
+/** Is the older version of product configuration */
+export declare const isAdditionalProductConfiguration: (value: DtoAdditionalProductConfiguration | DtoProductConf) => value is DtoAdditionalProductConfiguration;
+export declare const isDtoProductConfAdditional: (value: DtoProductConf) => value is DtoAdditionalProductConf;
+export declare const convertDtoProductConfToV1: (conf: DtoProductConf, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
+export declare const convertDtoFeatureConfsToSelOptions: (features: DtoFeatureConf[], silenceWarnings?: boolean) => DtoSelectedOption[];
+/**
+ * Serializes and compacts the configuration into a format especially suited for URLs
+ */
+export declare const dtoProductConfigurationToCompactString: (conf: DtoProductConf) => string;
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export declare const compactStringToDtoProductConf: (versionAndConf: string) => DtoProductConf;
+export declare const stripExtendedDataFromDtoProductConf: (conf: DtoProductConf, toStrip: CfgProdConfParts) => DtoProductConf;
+//# sourceMappingURL=utilitiesConfiguration.d.ts.map

package/dist/utilitiesConfiguration.js

@@ -0,0 +1,200 @@
+/**
+ * @param ExtendedData   Extra data, i.e. units and groupCodes
+ * @param ProductParams  What Product the conf is for, and the same for any Additional Products.
+ * @param SyncGroupState The current sync group state
+ */
+export var CfgProdConfParts;
+(function (CfgProdConfParts) {
+    CfgProdConfParts[CfgProdConfParts["NoExtra"] = 0] = "NoExtra";
+    CfgProdConfParts[CfgProdConfParts["ExtendedData"] = 1] = "ExtendedData";
+    CfgProdConfParts[CfgProdConfParts["ProdParams"] = 2] = "ProdParams";
+    CfgProdConfParts[CfgProdConfParts["SyncGroupState"] = 4] = "SyncGroupState";
+})(CfgProdConfParts || (CfgProdConfParts = {}));
+/** Is the newer version of product configuration */
+export const isProductConf = (value) => !("selOptions" in value);
+/** Is the older version of product configuration */
+export const isAdditionalProductConfiguration = (value) => "selOptions" in value;
+export const isDtoProductConfAdditional = (value) => "refKey" in value;
+// As this has potential to flood the terminal we only inform once
+let hasInformedAboutProdParams = false;
+let hasInformedAboutGroupCode = false;
+let hasInformedAboutUnit = false;
+export const convertDtoProductConfToV1 = (conf, silenceWarnings = false) => {
+    var _a, _b;
+    if (!silenceWarnings && conf.prodParams !== undefined && !hasInformedAboutProdParams) {
+        hasInformedAboutProdParams = true;
+        console.info("Incoming DtoProductConf contains prodParams. These will be ignored.");
+    }
+    const result = {
+        selOptions: ((_a = conf.features) !== null && _a !== void 0 ? _a : []).map((f) => ({
+            code: "!~!",
+            next: convertDtoFeatureConfToApiSelection(f, silenceWarnings),
+        })),
+        additionalProducts: ((_b = conf.additionalProducts) !== null && _b !== void 0 ? _b : []).map((p) => convertDtoProductConfToV1(p, silenceWarnings)),
+        selected: true,
+    };
+    if (isDtoProductConfAdditional(conf)) {
+        result.refKey = conf.refKey;
+        result.selected = conf.selected;
+    }
+    return result;
+};
+export const convertDtoFeatureConfsToSelOptions = (features, silenceWarnings = false) => (features !== null && features !== void 0 ? features : []).map((f) => ({
+    code: "!~!",
+    next: convertDtoFeatureConfToApiSelection(f, silenceWarnings),
+}));
+const convertDtoFeatureConfToApiSelection = (feature, silenceWarnings) => {
+    const { groupCode, options, unit } = feature;
+    if (!silenceWarnings && groupCode !== undefined && !hasInformedAboutGroupCode) {
+        hasInformedAboutGroupCode = true;
+        console.info("Incoming DtoFeature contains groupCode. It will be ignored.");
+    }
+    if (!silenceWarnings && unit !== undefined && !hasInformedAboutUnit) {
+        hasInformedAboutUnit = true;
+        console.info("Incoming DtoFeature contains a unit. It will be ignored.");
+    }
+    const result = {};
+    for (const option of (options !== null && options !== void 0 ? options : []).filter((o) => o.selected)) {
+        result[option.code] = convertDtoOptionConfToSelectedOption(option, silenceWarnings);
+    }
+    return result;
+};
+const convertDtoOptionConfToSelectedOption = (option, silenceWarnings) => {
+    const { features, code, numericValue } = option;
+    const selectionTrees = (features !== null && features !== void 0 ? features : []).map((f) => convertDtoFeatureConfToApiSelection(f, silenceWarnings));
+    const mergedSelectionTree = {};
+    let anyItems = false;
+    for (const selectionTree of selectionTrees) {
+        if (selectionTree === undefined) {
+            continue;
+        }
+        for (const key of Object.keys(selectionTree)) {
+            if (mergedSelectionTree[key] !== undefined) {
+                console.warn(`The key (${key}) is already used in the selection tree. Option code: "${code}".`);
+                continue;
+            }
+            mergedSelectionTree[key] = selectionTree[key];
+            anyItems = true;
+        }
+    }
+    const selectedOption = {
+        code,
+        numericValue,
+    };
+    if (anyItems) {
+        selectedOption.next = mergedSelectionTree;
+    }
+    return selectedOption;
+};
+const versionedRegex = /^v(\d+)(.+)$/;
+const jsonKeyRegex = /"([^"]+)":/g;
+const swapForUrlAdaptedRegex = /[-~_{}"]/g;
+const shortToLong = new Map();
+const longToShort = new Map();
+// The replacement scheme here assumes this will only be used for keys
+// in DtoProductConf and the knowledge that it contains no one
+// one char keys.
+for (const [long, short] of [
+    ["configuration", "c"],
+    ["additionalProducts", "a"],
+    ["prodParams", "p"],
+    ["refKey", "r"],
+    ["selected", "s"],
+    ["features", "f"],
+    ["code", "d"],
+    ["options", "o"],
+    ["numericValue", "n"],
+    ["groupCode", "g"],
+    ["unit", "u"],
+    ["syncGroupState", "sgs"],
+    ["selectOne", "so"],
+    ["selectMany", "sm"],
+    ["syncCode", "sc"],
+    ["optionCode", "oc"],
+]) {
+    shortToLong.set(short, long);
+    longToShort.set(long, short);
+}
+/**
+ * As certain chars are abundant in JSON but less abundant in the actual data
+ * we swap these so that frequent characters do not need to be URL-encoded.
+ */
+const jsonStringSwapCharsForUrl = (data) => data.replace(swapForUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "{":
+            return "~";
+        case "}":
+            return "-";
+        case '"':
+            return "_";
+        case "~":
+            return "{";
+        case "-":
+            return "}";
+        case "_":
+            return '"';
+        default:
+            throw new Error(`Unexpected char "${char}" in swap for URL`);
+    }
+});
+const compactDtoProductConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = longToShort.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+const expandDtoProductConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = shortToLong.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+/**
+ * Serializes and compacts the configuration into a format especially suited for URLs
+ */
+export const dtoProductConfigurationToCompactString = (conf) => "v1" +
+    jsonStringSwapCharsForUrl(compactDtoProductConfJsonKeys(JSON.stringify(conf, undefined, "")));
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export const compactStringToDtoProductConf = (versionAndConf) => {
+    const match = versionedRegex.exec(versionAndConf);
+    if (match === null) {
+        throw new Error("Could not match version string");
+    }
+    const [, version, conf] = match;
+    if (version !== "1") {
+        throw new Error("Unknown packed URL version");
+    }
+    if (conf === "") {
+        throw new Error("No conf found");
+    }
+    return JSON.parse(expandDtoProductConfJsonKeys(jsonStringSwapCharsForUrl(conf)));
+};
+export const stripExtendedDataFromDtoProductConf = (conf, toStrip) => {
+    var _a, _b;
+    const stripped = {
+        features: (_a = conf.features) === null || _a === void 0 ? void 0 : _a.map((f) => stripExtendedDataFromDtoFeatureConf(f, toStrip)),
+        additionalProducts: (_b = conf.additionalProducts) === null || _b === void 0 ? void 0 : _b.map(stripExtendedDataFromDtoAdditionalProductConfiguration),
+    };
+    if ((toStrip & CfgProdConfParts.SyncGroupState) !== CfgProdConfParts.SyncGroupState) {
+        stripped.syncGroupState = conf.syncGroupState;
+    }
+    if ((toStrip & CfgProdConfParts.ProdParams) !== CfgProdConfParts.ProdParams) {
+        stripped.prodParams = conf.prodParams;
+    }
+    return stripped;
+};
+const stripExtendedDataFromDtoAdditionalProductConfiguration = (conf, toStrip) => (Object.assign(Object.assign({}, stripExtendedDataFromDtoProductConf(conf, toStrip)), { refKey: conf.refKey, selected: conf.selected }));
+const stripExtendedDataFromDtoFeatureConf = (conf, toStrip) => {
+    var _a;
+    const stripped = {
+        code: conf.code,
+        options: (_a = conf.options) === null || _a === void 0 ? void 0 : _a.map((o) => stripExtendedDataFromDtoOptionConf(o, toStrip)),
+    };
+    if ((toStrip & CfgProdConfParts.ExtendedData) !== CfgProdConfParts.ExtendedData) {
+        // Keep in sync with getDtoConf in CfgFeature
+        stripped.groupCode = conf.groupCode;
+        stripped.unit = conf.unit;
+    }
+    return stripped;
+};
+const stripExtendedDataFromDtoOptionConf = (conf, toStrip) => {
+    var _a;
+    return ({
+        code: conf.code,
+        selected: conf.selected,
+        numericValue: conf.numericValue,
+        features: (_a = conf.features) === null || _a === void 0 ? void 0 : _a.map((f) => stripExtendedDataFromDtoFeatureConf(f, toStrip)),
+    });
+};