@configura/web-api 2.0.0-alpha.1 → 2.0.0-alpha.12

package/dist/CatalogueAPI.d.ts

@@ -5,6 +5,11 @@ export interface DtoAdditionalProductConfiguration {
     selOptions: Array<DtoSelectedOption>;
     additionalProducts?: Array<DtoAdditionalProductConfiguration>;
 }
+/** AdditionalProductConfigurationV2 */
+export interface DtoAdditionalProductConfigurationV2 extends DtoProductConfiguration {
+    refKey: string;
+    selected: boolean;
+}
 /** AdditionalProductRef */
 export interface DtoAdditionalProductRef {
     refKey: string;
@@ -22,7 +27,7 @@ export interface DtoApplicationArea {
     material?: string;
     preview?: string;
 }
-/** DtoApplicationAreasResponse */
+/** ApplicationAreasResponse */
 export interface DtoApplicationAreasResponse {
     applicationAreas: Array<DtoApplicationArea>;
     uuid: string;
@@ -74,31 +79,6 @@ export interface DtoCodeRange {
     maxValue: number;
     increment?: number;
 }
-/** ConfAddProd */
-export interface DtoConfAddProd extends DtoConfProd {
-    refKey: string;
-    selected: boolean;
-}
-/** ConfFeature */
-export interface DtoConfFeature {
-    code: string;
-    groupCode?: string;
-    unit?: string;
-    options?: Array<DtoConfOption>;
-}
-/** ConfOption */
-export interface DtoConfOption {
-    code: string;
-    selected: boolean;
-    numericValue?: DtoValueWithUnit;
-    features?: Array<DtoConfFeature>;
-}
-/** ConfProd */
-export interface DtoConfProd {
-    features?: Array<DtoConfFeature>;
-    additionalProducts?: Array<DtoConfAddProd>;
-    prodParams?: DtoProductParamsWithLang;
-}
 /** ErrorResponse */
 export interface DtoErrorResponse {
     error: string;
@@ -147,6 +127,13 @@ export interface DtoFeature {
     syncGroup?: DtoSyncGroup;
     unit?: string;
 }
+/** FeatureConfiguration */
+export interface DtoFeatureConfiguration {
+    code: string;
+    groupCode?: string;
+    unit?: string;
+    options?: Array<DtoOptionConfiguration>;
+}
 /** FeatureRef */
 export interface DtoFeatureRef {
     code: string;
@@ -176,7 +163,7 @@ export interface DtoGetPriceListsParams {
     vendor: string;
     priceList: string;
 }
-/** DtoProductParamsWithLang represents the URL parameters of getProduct */
+/** GetProductParams represents the URL parameters of getProduct */
 export interface DtoGetProductParams {
     lang: string;
     enterprise: string;
@@ -261,6 +248,13 @@ export interface DtoOption {
     upcharge?: number;
     priceCodes?: Array<string>;
 }
+/** OptionConfiguration */
+export interface DtoOptionConfiguration {
+    code: string;
+    selected: boolean;
+    numericValue?: DtoValueWithUnit;
+    features?: Array<DtoFeatureConfiguration>;
+}
 /** Orientation */
 export interface DtoOrientation {
     yaw: number;
@@ -359,6 +353,12 @@ export interface DtoProductCatalogueInfo {
     exchangeRate: number;
     lastModified: string;
 }
+/** ProductConfiguration */
+export interface DtoProductConfiguration {
+    features?: Array<DtoFeatureConfiguration>;
+    additionalProducts?: Array<DtoAdditionalProductConfigurationV2>;
+    prodParams?: DtoProductParamsWithLang;
+}
 /** ProductData */
 export interface DtoProductData {
     area?: string;

package/dist/CatalogueAPI.js

@@ -9,28 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-export const dtoExportFormatNames = [
-    "glb",
-    "gltf",
-    "fbx",
-    "dwg",
-    "cmdrw",
-    "cmfav",
-    "cmsym",
-];
-export const dtoExportStatusStatusNames = [
-    "pending",
-    "running",
-    "finished",
-    "failed",
-];
+export const dtoExportFormatNames = ["glb", "gltf", "fbx", "dwg", "cmdrw", "cmfav", "cmsym"];
+export const dtoExportStatusStatusNames = ["pending", "running", "finished", "failed"];
 export const dtoRenderFormatNames = ["jpg", "png"];
-export const dtoRenderStatusStatusNames = [
-    "pending",
-    "running",
-    "finished",
-    "failed",
-];
+export const dtoRenderStatusStatusNames = ["pending", "running", "finished", "failed"];
 export const dtoSyncGroupMethodsNames = ["pull", "push", "twoWay"];
 export class DtoAPIError extends Error {
 }
@@ -49,9 +31,7 @@ export class CatalogueAPI {
         }
     }
     hasFeature(feature) {
-        return (this.auth !== undefined &&
-            this.auth.apiSession.features !== undefined &&
-            this.auth.apiSession.features.indexOf(feature) > -1);
+        return this.auth !== undefined && this.auth.apiSession.features !== undefined && this.auth.apiSession.features.indexOf(feature) > -1;
     }
     fetch(url, options) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/CfgProduct.d.ts

@@ -1,5 +1,5 @@
 import { AggregatedLoadingObservable, LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoAdditionalProductConfiguration, DtoAdditionalProductRef, DtoCatalogueParams, DtoConfProd, DtoMeasureParam, DtoMtrlApplication, DtoPrices, DtoProductParamsWithLang, DtoTransform } from "./CatalogueAPI.js";
+import { DtoAdditionalProductConfiguration, DtoAdditionalProductRef, DtoCatalogueParams, DtoMeasureParam, DtoMtrlApplication, DtoPrices, DtoProductConfiguration, DtoProductParamsWithLang, DtoTransform } from "./CatalogueAPI.js";
 import { CfgMeasureDefinition } from "./CfgMeasure.js";
 import { _CfgFeatureInternal } from "./productConfiguration/CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
@@ -136,8 +136,8 @@ export declare class _CfgProductInternal {
     _additionalProductHasChanged: (freshRef: CfgProduct, bubbleMode: CfgProductBubbleMode, committed: boolean) => Promise<void>;
     /** Called by the configuration to tell its parent that it has changed. */
     _configurationHasChanged: (freshRef: CfgProductConfiguration, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
-    getDtoConf: (includeExtendedData: boolean, includeProductParams: boolean) => DtoConfProd;
-    setDtoConf: (s: DtoConfProd, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
+    getDtoConfiguration: (includeExtendedData: boolean, includeProductParams: boolean) => DtoProductConfiguration;
+    setDtoConfiguration: (s: DtoProductConfiguration, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     setApiSelection: (s: DtoAdditionalProductConfiguration, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     copyFrom: (source: _CfgProductInternal, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     private _setApiSelectionWithOtherProduct;
@@ -256,8 +256,8 @@ export declare class CfgProduct {
      * selections on a product is needed, such as when doing Render or Export.
      */
     getApiSelection: () => DtoAdditionalProductConfiguration;
-    getDtoConf: (includeExtendedData?: boolean, includeProductParams?: boolean) => DtoConfProd;
-    setDtoConf: (s: DtoConfProd, doValidate?: boolean) => Promise<boolean>;
+    getDtoConfiguration: (includeExtendedData?: boolean, includeProductParams?: boolean) => DtoProductConfiguration;
+    setDtoConfiguration: (s: DtoProductConfiguration, doValidate?: boolean) => Promise<boolean>;
     setApiSelection: (s: DtoAdditionalProductConfiguration, doValidate?: boolean) => Promise<boolean>;
     listenForChange: (l: SingleArgCallback<CfgProductChangeNotification>) => void;
     stopListenForChange: (l: SingleArgCallback<CfgProductChangeNotification>) => void;

package/dist/CfgProduct.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { AggregatedLoadingObservable, assert, assertDefined, augmentErrorMessage, compareArrays, count, Observable, toLengthUnit, } from "@configura/web-utilities";
 import { CfgMeasureDefinition } from "./CfgMeasure.js";
-import { convertDtoConfProdToV1 } from "./ConfigurationConverter.js";
+import { convertDtoProductConfigurationToV1 } from "./ConfigurationConverter.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
 import { CfgProductConfiguration } from "./productConfiguration/CfgProductConfiguration.js";
 import { collectAdditionalProductRefs } from "./productConfiguration/utilitiesProductConfiguration.js";
@@ -140,9 +140,9 @@ export class _CfgProductInternal {
                     return;
             }
         });
-        this.getDtoConf = (includeExtendedData, includeProductParams) => {
+        this.getDtoConfiguration = (includeExtendedData, includeProductParams) => {
             const conf = {};
-            const features = this.configuration._internal.getDtoConf(includeExtendedData);
+            const features = this.configuration._internal.getDtoConfiguration(includeExtendedData);
             if (0 < features.length) {
                 conf.features = features;
             }
@@ -151,7 +151,7 @@ export class _CfgProductInternal {
             }
             const additionalProducts = this.additionalProducts;
             if (0 < additionalProducts.length) {
-                conf.additionalProducts = additionalProducts.map((p) => p._internal.getDtoConf(includeExtendedData, includeProductParams));
+                conf.additionalProducts = additionalProducts.map((p) => p._internal.getDtoConfiguration(includeExtendedData, includeProductParams));
             }
             if (this.isAdditionalProduct) {
                 const refKey = this.refKey;
@@ -164,12 +164,14 @@ export class _CfgProductInternal {
             }
             return conf;
         };
-        this.setDtoConf = (s, doValidate, productLoaderForGroupedLoad) => this.setApiSelection(convertDtoConfProdToV1(s), doValidate, productLoaderForGroupedLoad);
+        this.setDtoConfiguration = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.setApiSelection(convertDtoProductConfigurationToV1(s), doValidate, productLoaderForGroupedLoad);
+        });
         this.setApiSelection = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return this._setApiSelectionWithOtherProduct(s, doValidate, productLoaderForGroupedLoad, undefined);
+            return yield this._setApiSelectionWithOtherProduct(s, doValidate, productLoaderForGroupedLoad, undefined);
         });
         this.copyFrom = (source, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._setApiSelectionWithOtherProduct(convertDtoConfProdToV1(source.getDtoConf(false, false)), doValidate, productLoaderForGroupedLoad, source);
+            return yield this._setApiSelectionWithOtherProduct(convertDtoProductConfigurationToV1(source.getDtoConfiguration(false, false)), doValidate, productLoaderForGroupedLoad, source);
         });
         this._setApiSelectionWithOtherProduct = (s, doValidate, productLoaderForGroupedLoad, sourceProduct) => __awaiter(this, void 0, void 0, function* () {
             // Wrap with cache will make getProduct for this function call use the same server call
@@ -203,8 +205,8 @@ export class _CfgProductInternal {
             const sourceProductAdditionalProducts = sourceProduct === null || sourceProduct === void 0 ? void 0 : sourceProduct.additionalProducts;
             assert(!sourceProductAdditionalProducts ||
                 additionalProductsCount === sourceProductAdditionalProducts.length, `Passed sourceProduct does not have the same number of additional products as this.`);
-            if ((yield Promise.all(apiSelectionAdditionalProducts.map((apiSelectionAdditionalProduct, index) => {
-                var _a;
+            if ((yield Promise.all(apiSelectionAdditionalProducts.map((apiSelectionAdditionalProduct) => __awaiter(this, void 0, void 0, function* () {
+                var _b;
                 const refKey = apiSelectionAdditionalProduct.refKey;
                 assertDefined(refKey, "Additional product api configurations must have refKey.");
                 const i = additionalProducts.findIndex((a) => refKey === a.refKey);
@@ -212,12 +214,12 @@ export class _CfgProductInternal {
                 let sourceProductAdditionalProduct = undefined;
                 if (sourceProductAdditionalProducts !== undefined) {
                     sourceProductAdditionalProduct =
-                        (_a = sourceProductAdditionalProducts.find((a) => refKey === a.refKey)) === null || _a === void 0 ? void 0 : _a._internal;
+                        (_b = sourceProductAdditionalProducts.find((a) => refKey === a.refKey)) === null || _b === void 0 ? void 0 : _b._internal;
                     assertDefined(sourceProductAdditionalProduct, "Additional product not found in sourceProduct");
                 }
                 const additionalProduct = additionalProducts.splice(i, 1)[0]; // Splicing like this is okay because this is done synchronous. The setCon. is what is async.
-                return additionalProduct._internal._setApiSelectionWithOtherProduct(apiSelectionAdditionalProduct, doValidate, productLoaderForGroupedLoad, sourceProductAdditionalProduct);
-            }))).some((b) => b)) {
+                return yield additionalProduct._internal._setApiSelectionWithOtherProduct(apiSelectionAdditionalProduct, doValidate, productLoaderForGroupedLoad, sourceProductAdditionalProduct);
+            })))).some((b) => b)) {
                 change = true;
             }
             if (doValidate && configurationChange) {
@@ -419,7 +421,7 @@ export class _CfgProductInternal {
             }
         });
         this.root = root !== null && root !== void 0 ? root : this;
-        this.key = makeProductKey(prodParams, (_a = _additionalProductRef === null || _additionalProductRef === void 0 ? void 0 : _additionalProductRef.refKey) !== null && _a !== void 0 ? _a : prodParams.partNumber);
+        this.key = makeProductKey(Object.assign(Object.assign({}, prodParams), { partNumber: (_a = _additionalProductRef === null || _additionalProductRef === void 0 ? void 0 : _additionalProductRef.refKey) !== null && _a !== void 0 ? _a : prodParams.partNumber }));
         this._selected = optional ? selected : undefined;
         this.isAdditionalProduct = parent !== undefined;
         this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, allRawFeatures, apiSelection, this, this.root);
@@ -649,9 +651,9 @@ export class CfgProduct {
          * configuration, optional products and additional products. Used when a full view of all
          * selections on a product is needed, such as when doing Render or Export.
          */
-        this.getApiSelection = () => convertDtoConfProdToV1(this._internal.getDtoConf(false, false), true);
-        this.getDtoConf = (includeExtendedData = false, includeProductParams = false) => this._internal.getDtoConf(includeExtendedData, includeProductParams);
-        this.setDtoConf = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConf(s, doValidate); });
+        this.getApiSelection = () => convertDtoProductConfigurationToV1(this._internal.getDtoConfiguration(false, false), true);
+        this.getDtoConfiguration = (includeExtendedData = false, includeProductParams = false) => this._internal.getDtoConfiguration(includeExtendedData, includeProductParams);
+        this.setDtoConfiguration = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConfiguration(s, doValidate); });
         this.setApiSelection = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(s, doValidate); });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);

package/dist/CfgReferencePathHelper.d.ts

@@ -8,7 +8,20 @@ import { DtoCatalogueParamsWithLang, DtoProductParamsWithLang } from "./Catalogu
  * Internally at Configura we try to stick with this format.
  */
 export declare class CfgReferencePathHelper {
+    /**
+     * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+     * @param browsingRootUrl The URL where Stage browsing begins
+     * @param catParams What catalogue to generate URL for.
+     * @returns An URL to a catalogue
+     */
     static getCataloguePath: (browsingRootUrl: string, catParams: DtoCatalogueParamsWithLang) => string;
-    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithLang) => string;
+    /**
+     * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+     * @param browsingRootUrl The URL where Stage browsing begins
+     * @param productParams What product to generate URL for.
+     * @param separator Optional, defaults to "product", but can be changed to indicate another function.
+     * @returns An URL to a product
+     */
+    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithLang, separator?: string) => string;
 }
 //# sourceMappingURL=CfgReferencePathHelper.d.ts.map

package/dist/CfgReferencePathHelper.js

@@ -9,5 +9,18 @@ import { encodeURIComponents } from "@configura/web-utilities";
  */
 export class CfgReferencePathHelper {
 }
+/**
+ * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+ * @param browsingRootUrl The URL where Stage browsing begins
+ * @param catParams What catalogue to generate URL for.
+ * @returns An URL to a catalogue
+ */
 CfgReferencePathHelper.getCataloguePath = (browsingRootUrl, catParams) => `${browsingRootUrl}/${encodeURIComponents(catParams.cid, catParams.lang, catParams.enterprise, catParams.prdCat, catParams.prdCatVersion, catParams.vendor, catParams.priceList)}`;
-CfgReferencePathHelper.getProductPath = (browsingRootUrl, productParams) => `${CfgReferencePathHelper.getCataloguePath(browsingRootUrl, productParams)}/product/${encodeURIComponent(productParams.partNumber)}`;
+/**
+ * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+ * @param browsingRootUrl The URL where Stage browsing begins
+ * @param productParams What product to generate URL for.
+ * @param separator Optional, defaults to "product", but can be changed to indicate another function.
+ * @returns An URL to a product
+ */
+CfgReferencePathHelper.getProductPath = (browsingRootUrl, productParams, separator = "product") => `${CfgReferencePathHelper.getCataloguePath(browsingRootUrl, productParams)}/${separator}/${encodeURIComponent(productParams.partNumber)}`;

package/dist/ConfigurationConverter.d.ts

@@ -1,5 +1,13 @@
-import { DtoAdditionalProductConfiguration, DtoConfAddProd, DtoConfFeature, DtoConfProd, DtoSelectedOption } from "./CatalogueAPI.js";
-export declare const isDtoConfProdAdditional: (value: DtoConfProd) => value is DtoConfAddProd;
-export declare const convertDtoConfProdToV1: (conf: DtoConfProd, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
-export declare const convertDtoConfFeaturesToSelOptions: (features: DtoConfFeature[], silenceWarnings?: boolean) => DtoSelectedOption[];
+import { DtoAdditionalProductConfiguration, DtoAdditionalProductConfigurationV2, DtoFeatureConfiguration, DtoProductConfiguration, DtoSelectedOption } from "./CatalogueAPI.js";
+export declare const isDtoProductConfigurationAdditional: (value: DtoProductConfiguration) => value is DtoAdditionalProductConfigurationV2;
+export declare const convertDtoProductConfigurationToV1: (conf: DtoProductConfiguration, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
+export declare const convertDtoFeatureConfigurationsToSelOptions: (features: DtoFeatureConfiguration[], silenceWarnings?: boolean) => DtoSelectedOption[];
+/**
+ * Serializes and compacts the configuration into a format especially suited for URLs
+ */
+export declare const dtoProductConfigurationToCompactString: (conf: DtoProductConfiguration) => string;
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export declare const compactStringToDtoProductConfiguration: (versionAndConf: string) => DtoProductConfiguration;
 //# sourceMappingURL=ConfigurationConverter.d.ts.map

package/dist/ConfigurationConverter.js

@@ -1,9 +1,9 @@
-export const isDtoConfProdAdditional = (value) => "refKey" in value;
+export const isDtoProductConfigurationAdditional = (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 convertDtoConfProdToV1 = (conf, silenceWarnings = false) => {
+export const convertDtoProductConfigurationToV1 = (conf, silenceWarnings = false) => {
     var _a, _b;
     if (!silenceWarnings && conf.prodParams !== undefined && !hasInformedAboutProdParams) {
         hasInformedAboutProdParams = true;
@@ -12,22 +12,22 @@ export const convertDtoConfProdToV1 = (conf, silenceWarnings = false) => {
     const result = {
         selOptions: ((_a = conf.features) !== null && _a !== void 0 ? _a : []).map((f) => ({
             code: "!~!",
-            next: convertDtoConfFeatureToApiSelection(f, silenceWarnings),
+            next: convertDtoFeatureConfigurationToApiSelection(f, silenceWarnings),
         })),
-        additionalProducts: ((_b = conf.additionalProducts) !== null && _b !== void 0 ? _b : []).map((p) => convertDtoConfProdToV1(p, silenceWarnings)),
+        additionalProducts: ((_b = conf.additionalProducts) !== null && _b !== void 0 ? _b : []).map((p) => convertDtoProductConfigurationToV1(p, silenceWarnings)),
         selected: true,
     };
-    if (isDtoConfProdAdditional(conf)) {
+    if (isDtoProductConfigurationAdditional(conf)) {
         result.refKey = conf.refKey;
         result.selected = conf.selected;
     }
     return result;
 };
-export const convertDtoConfFeaturesToSelOptions = (features, silenceWarnings = false) => (features !== null && features !== void 0 ? features : []).map((f) => ({
+export const convertDtoFeatureConfigurationsToSelOptions = (features, silenceWarnings = false) => (features !== null && features !== void 0 ? features : []).map((f) => ({
     code: "!~!",
-    next: convertDtoConfFeatureToApiSelection(f, silenceWarnings),
+    next: convertDtoFeatureConfigurationToApiSelection(f, silenceWarnings),
 }));
-const convertDtoConfFeatureToApiSelection = (feature, silenceWarnings) => {
+const convertDtoFeatureConfigurationToApiSelection = (feature, silenceWarnings) => {
     const { groupCode, options, unit } = feature;
     if (!silenceWarnings && groupCode !== undefined && !hasInformedAboutGroupCode) {
         hasInformedAboutGroupCode = true;
@@ -39,13 +39,13 @@ const convertDtoConfFeatureToApiSelection = (feature, silenceWarnings) => {
     }
     const result = {};
     for (const option of (options !== null && options !== void 0 ? options : []).filter((o) => o.selected)) {
-        result[option.code] = convertDtoConfOptionToSelectedOption(option, silenceWarnings);
+        result[option.code] = convertDtoOptionConfigurationToSelectedOption(option, silenceWarnings);
     }
     return result;
 };
-const convertDtoConfOptionToSelectedOption = (option, silenceWarnings) => {
+const convertDtoOptionConfigurationToSelectedOption = (option, silenceWarnings) => {
     const { features, code, numericValue } = option;
-    const selectionTrees = (features !== null && features !== void 0 ? features : []).map((f) => convertDtoConfFeatureToApiSelection(f, silenceWarnings));
+    const selectionTrees = (features !== null && features !== void 0 ? features : []).map((f) => convertDtoFeatureConfigurationToApiSelection(f, silenceWarnings));
     const mergedSelectionTree = {};
     let anyItems = false;
     for (const selectionTree of selectionTrees) {
@@ -70,3 +70,80 @@ const convertDtoConfOptionToSelectedOption = (option, silenceWarnings) => {
     }
     return selectedOption;
 };
+const versionedRegex = /^v(\d+)(.+)$/;
+const jsonKeyRegex = /"([^"]+)":/g;
+const swapIntoUrlAdaptedRegex = /[{}"]/g;
+const swapFromUrlAdaptedRegex = /[-~_]/g;
+const shortToLong = new Map();
+const longToShort = new Map();
+// The replacement scheme here assumes this will only be used for keys
+// in DtoProductConfiguration 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"],
+]) {
+    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(swapIntoUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "{":
+            return "~";
+        case "}":
+            return "-";
+        case '"':
+            return "_";
+        default:
+            throw new Error(`Unexpected char "${char}" in swap for URL`);
+    }
+});
+const jsonStringSwapCharsFromUrl = (data) => data.replace(swapFromUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "~":
+            return "{";
+        case "-":
+            return "}";
+        case "_":
+            return '"';
+        default:
+            throw new Error(`Unexpected char "${char}" in swap from URL`);
+    }
+});
+const compactDtoProductConfigurationJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = longToShort.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+const expandDtoProductConfigurationJsonKeys = (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(compactDtoProductConfigurationJsonKeys(JSON.stringify(conf, undefined, "")));
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export const compactStringToDtoProductConfiguration = (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(expandDtoProductConfigurationJsonKeys(jsonStringSwapCharsFromUrl(conf)));
+};

package/dist/io/CfgHistoryManager.d.ts

@@ -4,7 +4,8 @@ declare type CfgHistoryManagerMessageData = {
 };
 /**
  * The collected data used when sending. For history this both contains the message, which is
- * used as the "state" in the history-frame, and the qsKeyValues, which are used in the URL.
+ * used as the "state" in the history-frame, and the qsKeyValues, which are query string
+ * key-values used in the URL.
  * When navigating back and forth the stage (message) is used to restore the old state. When
  * opening a window with no prior history the Query String will be used.
  */
@@ -14,8 +15,8 @@ export declare type CfgHistoryManagerSendData<D> = {
     qsKeyValues: Map<string, string | undefined>;
 };
 /**
- * This class does nothing on it's own. It is used to coordinate writing to the history, that
- * is, updating the browsing history.
+ * This class is used to coordinate writing and reading to the browser history.
+ * It handles messages sent from the connectors.
  */
 export declare class CfgHistoryManager extends CfgWindowEventManager<"popstate", CfgHistoryManagerSendData<CfgHistoryManagerMessageData>> {
     private static _instance;

package/dist/io/CfgHistoryManager.js

@@ -2,8 +2,8 @@ import { mapQueryString, unmapQueryString } from "@configura/web-utilities";
 import { CfgIOManager } from "./CfgIOManager.js";
 import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 /**
- * This class does nothing on it's own. It is used to coordinate writing to the history, that
- * is, updating the browsing history.
+ * This class is used to coordinate writing and reading to the browser history.
+ * It handles messages sent from the connectors.
  */
 export class CfgHistoryManager extends CfgWindowEventManager {
     constructor() {

package/dist/io/CfgHistoryToProdConfConnector.d.ts

@@ -1,8 +1,6 @@
-import { DtoConfProd } from "../CatalogueAPI.js";
+import { DtoProductConfiguration } from "../CatalogueAPI.js";
 import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
-export declare function dtoConfToString(conf: DtoConfProd): string;
-export declare function stringToDtoConf(conf: string): DtoConfProd;
 /**
  * Instantiating this will make the browser history (and URL) update with the product configuration.
  */
@@ -15,7 +13,7 @@ export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnecto
      * @param doValidate When popping from the history stack (navigating in the browser), should a navigate call be sent to the server to verify that the product configuration is still valid?
      */
     constructor(manager: CfgHistoryManager, _useHistoryPush: boolean, _qsKey?: string, doValidate?: boolean);
-    protected getInitialProdConf(): DtoConfProd | undefined;
-    protected makeSendData(conf: DtoConfProd, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
+    protected getInitialProdConf(): DtoProductConfiguration | undefined;
+    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
 }
 //# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -1,30 +1,6 @@
+import { compactStringToDtoProductConfiguration, dtoProductConfigurationToCompactString, } from "../ConfigurationConverter.js";
 import { CfgHistoryManager } from "./CfgHistoryManager.js";
 import { CfgIOProdConfConnector, CfgProdConfMessageVersions, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
-const jsonKeyRegex = /"([^"]+)":/g;
-const keyMap = [
-    ["configuration", "cn"],
-    ["additionalProducts", "as"],
-    ["prodParams", "pp"],
-    ["refKey", "rk"],
-    ["selected", "se"],
-    ["features", "fs"],
-    ["code", "cd"],
-    ["options", "os"],
-    ["numericValue", "nu"],
-    ["groupCode", "gc"],
-    ["unit", "un"],
-];
-// todo: Could be worth making faster
-const toCompact = (key) => { var _a, _b; return (_b = (_a = keyMap.find((i) => i[0] === key)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : key; };
-const toExpanded = (key) => { var _a, _b; return (_b = (_a = keyMap.find((i) => i[1] === key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : key; };
-export function dtoConfToString(conf) {
-    const stringified = JSON.stringify(conf, undefined, "");
-    return stringified.replace(jsonKeyRegex, (_, key) => `"${toCompact(key)}":`);
-}
-export function stringToDtoConf(conf) {
-    const expandedKeys = conf.replace(jsonKeyRegex, (_, key) => `"${toExpanded(key)}":`);
-    return JSON.parse(expandedKeys);
-}
 /**
  * Instantiating this will make the browser history (and URL) update with the product configuration.
  */
@@ -35,7 +11,7 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
      * @param doValidate When popping from the history stack (navigating in the browser), should a navigate call be sent to the server to verify that the product configuration is still valid?
      */
     constructor(manager, _useHistoryPush, _qsKey = STAGE_PROD_CONF_MESSAGE_KEY, doValidate = true) {
-        super(manager, doValidate, CfgProdConfMessageVersions.V2dot0, false, false);
+        super(manager, doValidate, false, false);
         this._useHistoryPush = _useHistoryPush;
         this._qsKey = _qsKey;
     }
@@ -44,12 +20,14 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
         if (s === undefined) {
             return undefined;
         }
-        return stringToDtoConf(s);
+        return compactStringToDtoProductConfiguration(s);
     }
     makeSendData(conf, initial) {
         return {
-            message: this.makeMessage(conf, initial),
-            qsKeyValues: new Map([[STAGE_PROD_CONF_MESSAGE_KEY, dtoConfToString(conf)]]),
+            message: CfgIOProdConfConnector.makeMessage(conf, initial, CfgProdConfMessageVersions.V2dot0),
+            qsKeyValues: new Map([
+                [STAGE_PROD_CONF_MESSAGE_KEY, dtoProductConfigurationToCompactString(conf)],
+            ]),
             useHistoryPush: this._useHistoryPush,
         };
     }

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -1,53 +1,56 @@
-import { DtoAdditionalProductConfiguration, DtoConfProd } from "../CatalogueAPI.js";
+import { DtoAdditionalProductConfiguration, DtoProductConfiguration } from "../CatalogueAPI.js";
 import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
 import { CfgIOManager } from "./CfgIOManager.js";
+export declare const isCfgProdConfMessage: (data: unknown) => data is CfgProdConfMessageV1 | CfgProdConfMessageV2;
 export declare type CfgProdConfMessageV1 = {
     version: "1.0";
     conf: DtoAdditionalProductConfiguration;
 };
+export declare const isCfgProdConfMessageV1: (data: unknown) => data is CfgProdConfMessageV1;
 export declare type CfgProdConfMessageV2 = {
     version: "2.0";
-    conf: DtoConfProd;
+    conf: DtoProductConfiguration;
 };
+export declare const isCfgProdConfMessageV2: (data: unknown) => data is CfgProdConfMessageV2;
 export declare type CfgProdConfMessage = {
     initial: boolean;
     subMessages: (CfgProdConfMessageV1 | CfgProdConfMessageV2)[];
 };
+export declare const getHighestVersionProdConfMessage: (subMessages: (CfgProdConfMessageV1 | CfgProdConfMessageV2)[]) => CfgProdConfMessageV1 | CfgProdConfMessageV2;
 export declare enum CfgProdConfMessageVersions {
     V1dot0 = 1,
     V2dot0 = 2
 }
 export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
 declare type ProdConfMessageCallback = (message: CfgProdConfMessage) => Promise<void>;
-declare type ProdConfCallback = (conf: DtoConfProd) => Promise<void>;
+declare type ProdConfCallback = (conf: DtoProductConfiguration) => Promise<void>;
 /**
  * Base class for connecting the product configuration to an IO channel
  */
 export declare abstract class CfgIOProdConfConnector<S> {
     private readonly _ioManager;
     private readonly _doValidate;
-    private readonly _sendVersions;
     private readonly _includeExtendedDataInSend;
     private readonly _includeProdParamsInSend;
     private _product;
     private _stopListenToMessage;
     private _stopListenToProdConf;
-    constructor(_ioManager: CfgIOManager<S>, _doValidate: boolean, _sendVersions: CfgProdConfMessageVersions, _includeExtendedDataInSend: boolean, // Only v2.0
+    constructor(_ioManager: CfgIOManager<S>, _doValidate: boolean, _includeExtendedDataInSend: boolean, // Only v2.0
     _includeProdParamsInSend: boolean);
     destroy: () => void;
     setProduct: (product: CfgProduct | undefined) => Promise<void>;
     private _send;
-    protected getInitialProdConf(): DtoConfProd | undefined;
-    protected abstract makeSendData(conf: DtoConfProd, initial: boolean): S;
-    makeMessage(conf: DtoConfProd, initial: boolean): CfgProdConfMessage;
-    makeMessageListener(callback: ProdConfMessageCallback): (message: unknown) => Promise<void>;
+    protected getInitialProdConf(): DtoProductConfiguration | undefined;
+    protected abstract makeSendData(conf: DtoProductConfiguration, initial: boolean): S;
+    static makeMessage(conf: DtoProductConfiguration, initial: boolean, sendVersions: CfgProdConfMessageVersions): CfgProdConfMessage;
+    static makeMessageListener(callback: ProdConfMessageCallback): (message: unknown) => Promise<void>;
     /**
      * Register the callback to listen for Product Configuration messages
      * @returns A function which when called will cancel listening
      */
-    listenForMessage(callback: ProdConfMessageCallback): () => void;
-    makeProdConfListener(callback: ProdConfCallback): (n: CfgProductChangeNotification) => void;
-    listenForProdConf(product: CfgProduct, callback: ProdConfCallback): () => void;
+    static listenForMessage<S>(callback: ProdConfMessageCallback, ioManager: CfgIOManager<S>): () => void;
+    static makeProdConfListener(callback: ProdConfCallback, includeExtendedDataInSend: boolean, includeProdParamsInSend: boolean): (n: CfgProductChangeNotification) => void;
+    static listenForProdConf(product: CfgProduct, callback: ProdConfCallback, includeExtendedDataInSend: boolean, includeProdParamsInSend: boolean): () => void;
 }
 export {};
 //# sourceMappingURL=CfgIOProdConfConnector.d.ts.map

package/dist/io/CfgIOProdConfConnector.js

@@ -7,7 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { convertDtoConfProdToV1 } from "../ConfigurationConverter.js";
+import { convertDtoProductConfigurationToV1 } from "../ConfigurationConverter.js";
+export const isCfgProdConfMessage = (data) => typeof data === "object" && data !== null && "version" in data && "conf" in data;
+export const isCfgProdConfMessageV1 = (data) => isCfgProdConfMessage(data) && data.version === "1.0";
+export const isCfgProdConfMessageV2 = (data) => isCfgProdConfMessage(data) && data.version === "2.0";
+export const getHighestVersionProdConfMessage = (subMessages) => subMessages
+    .slice(1)
+    .reduce((a, c) => (a.version < c.version ? c : a), subMessages[0]);
 export var CfgProdConfMessageVersions;
 (function (CfgProdConfMessageVersions) {
     CfgProdConfMessageVersions[CfgProdConfMessageVersions["V1dot0"] = 1] = "V1dot0";
@@ -18,12 +24,11 @@ export const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
  * Base class for connecting the product configuration to an IO channel
  */
 export class CfgIOProdConfConnector {
-    constructor(_ioManager, _doValidate, _sendVersions, _includeExtendedDataInSend, // Only v2.0
+    constructor(_ioManager, _doValidate, _includeExtendedDataInSend, // Only v2.0
     _includeProdParamsInSend // Only v2.0
     ) {
         this._ioManager = _ioManager;
         this._doValidate = _doValidate;
-        this._sendVersions = _sendVersions;
         this._includeExtendedDataInSend = _includeExtendedDataInSend;
         this._includeProdParamsInSend = _includeProdParamsInSend;
         this._stopListenToMessage = undefined;
@@ -55,47 +60,45 @@ export class CfgIOProdConfConnector {
             if (currentProduct === undefined) {
                 const initialProdConf = this.getInitialProdConf();
                 if (initialProdConf !== undefined) {
-                    yield newProduct.setDtoConf(initialProdConf, this._doValidate);
+                    yield newProduct.setDtoConfiguration(initialProdConf, this._doValidate);
                 }
             }
-            this._send(this.makeSendData(newProduct.getDtoConf(this._includeExtendedDataInSend, this._includeProdParamsInSend), true));
-            this._stopListenToMessage = this.listenForMessage((messages) => __awaiter(this, void 0, void 0, function* () {
+            this._send(this.makeSendData(newProduct.getDtoConfiguration(this._includeExtendedDataInSend, this._includeProdParamsInSend), true));
+            this._stopListenToMessage = CfgIOProdConfConnector.listenForMessage((messages) => __awaiter(this, void 0, void 0, function* () {
                 const subMessages = messages.subMessages;
                 if (subMessages.length === 0) {
                     console.warn(`${STAGE_PROD_CONF_MESSAGE_KEY} message without any submessages. Unexpected.`);
                     return;
                 }
-                const highestVersionMessage = subMessages
-                    .slice(1)
-                    .reduce((a, c) => (a.version < c.version ? c : a), subMessages[0]);
-                switch (highestVersionMessage.version) {
-                    case "1.0":
-                        yield newProduct.setApiSelection(highestVersionMessage.conf, this._doValidate);
-                        return;
-                    case "2.0":
-                        yield newProduct.setDtoConf(highestVersionMessage.conf, this._doValidate);
-                        return;
+                const highestVersionMessage = getHighestVersionProdConfMessage(subMessages);
+                if (isCfgProdConfMessageV1(highestVersionMessage)) {
+                    yield newProduct.setApiSelection(highestVersionMessage.conf, this._doValidate);
+                    return;
+                }
+                if (isCfgProdConfMessageV2(highestVersionMessage)) {
+                    yield newProduct.setDtoConfiguration(highestVersionMessage.conf, this._doValidate);
+                    return;
                 }
                 throw new Error("Unknown message version");
-            }));
-            this._stopListenToProdConf = this.listenForProdConf(newProduct, (conf) => __awaiter(this, void 0, void 0, function* () { return this._send(this.makeSendData(conf, false)); }));
+            }), this._ioManager);
+            this._stopListenToProdConf = CfgIOProdConfConnector.listenForProdConf(newProduct, (conf) => __awaiter(this, void 0, void 0, function* () { return this._send(this.makeSendData(conf, false)); }), this._includeExtendedDataInSend, this._includeProdParamsInSend);
         });
         this._send = (data) => this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, data);
     }
     getInitialProdConf() {
         return undefined;
     }
-    makeMessage(conf, initial) {
+    static makeMessage(conf, initial, sendVersions) {
         const result = [];
-        if ((this._sendVersions & CfgProdConfMessageVersions.V1dot0) ===
+        if ((sendVersions & CfgProdConfMessageVersions.V1dot0) ===
             CfgProdConfMessageVersions.V1dot0) {
             const v1 = {
                 version: "1.0",
-                conf: convertDtoConfProdToV1(conf, true),
+                conf: convertDtoProductConfigurationToV1(conf, true),
             };
             result.push(v1);
         }
-        if ((this._sendVersions & CfgProdConfMessageVersions.V2dot0) ===
+        if ((sendVersions & CfgProdConfMessageVersions.V2dot0) ===
             CfgProdConfMessageVersions.V2dot0) {
             const v2 = {
                 version: "2.0",
@@ -105,7 +108,7 @@ export class CfgIOProdConfConnector {
         }
         return { subMessages: result, initial };
     }
-    makeMessageListener(callback) {
+    static makeMessageListener(callback) {
         return (message) => __awaiter(this, void 0, void 0, function* () {
             const prodConfMessage = message;
             yield callback(prodConfMessage);
@@ -115,24 +118,23 @@ export class CfgIOProdConfConnector {
      * Register the callback to listen for Product Configuration messages
      * @returns A function which when called will cancel listening
      */
-    listenForMessage(callback) {
-        const ioManager = this._ioManager;
+    static listenForMessage(callback, ioManager) {
         const listener = this.makeMessageListener(callback);
         ioManager.listenForMessage(listener, STAGE_PROD_CONF_MESSAGE_KEY);
         return () => {
             ioManager.stopListenForMessage(listener);
         };
     }
-    makeProdConfListener(callback) {
+    static makeProdConfListener(callback, includeExtendedDataInSend, includeProdParamsInSend) {
         return (n) => {
             if (!n.committed) {
                 return;
             }
-            callback(n.freshRef.getDtoConf(this._includeExtendedDataInSend, this._includeProdParamsInSend));
+            callback(n.freshRef.getDtoConfiguration(includeExtendedDataInSend, includeProdParamsInSend));
         };
     }
-    listenForProdConf(product, callback) {
-        const listener = this.makeProdConfListener(callback);
+    static listenForProdConf(product, callback, includeExtendedDataInSend, includeProdParamsInSend) {
+        const listener = this.makeProdConfListener(callback, includeExtendedDataInSend, includeProdParamsInSend);
         product.listenForChange(listener);
         return () => {
             product.stopListenForChange(listener);

package/dist/io/CfgObservableStateManager.d.ts

@@ -1,5 +1,9 @@
 import { Observable } from "@configura/web-utilities";
 import { CfgIOManager, IOManagerListener } from "./CfgIOManager.js";
+/**
+ * This class is used to coordinate sending and receiving using the observable
+ * state in the class. It handles messages sent from the connectors.
+ */
 export declare class CfgObservableStateManager extends CfgIOManager<unknown> {
     private static _instance;
     static get instance(): CfgObservableStateManager;

package/dist/io/CfgObservableStateManager.js

@@ -1,5 +1,9 @@
 import { Observable } from "@configura/web-utilities";
 import { CfgIOManager } from "./CfgIOManager.js";
+/**
+ * This class is used to coordinate sending and receiving using the observable
+ * state in the class. It handles messages sent from the connectors.
+ */
 export class CfgObservableStateManager extends CfgIOManager {
     constructor() {
         super();

package/dist/io/CfgObservableStateToProdConfConnector.d.ts

@@ -1,4 +1,4 @@
-import { DtoConfProd } from "../CatalogueAPI.js";
+import { DtoProductConfiguration } from "../CatalogueAPI.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage, CfgProdConfMessageVersions } from "./CfgIOProdConfConnector.js";
 import { CfgObservableStateManager } from "./CfgObservableStateManager.js";
 /**
@@ -9,7 +9,8 @@ import { CfgObservableStateManager } from "./CfgObservableStateManager.js";
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export declare class CfgObservableStateToProdConfConnector extends CfgIOProdConfConnector<CfgProdConfMessage> {
-    constructor(manager: CfgObservableStateManager, doValidate?: boolean, sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoConfProd, initial: boolean): CfgProdConfMessage;
+    private _sendVersions;
+    constructor(manager: CfgObservableStateManager, doValidate?: boolean, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
+    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgProdConfMessage;
 }
 //# sourceMappingURL=CfgObservableStateToProdConfConnector.d.ts.map

package/dist/io/CfgObservableStateToProdConfConnector.js

@@ -7,10 +7,11 @@ import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProd
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export class CfgObservableStateToProdConfConnector extends CfgIOProdConfConnector {
-    constructor(manager, doValidate = true, sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
-        super(manager, doValidate, sendVersions, includeExtendedDataInSend, includeProdParamsInSend);
+    constructor(manager, doValidate = true, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, doValidate, includeExtendedDataInSend, includeProdParamsInSend);
+        this._sendVersions = _sendVersions;
     }
     makeSendData(conf, initial) {
-        return this.makeMessage(conf, initial);
+        return CfgIOProdConfConnector.makeMessage(conf, initial, this._sendVersions);
     }
 }

package/dist/io/CfgWindowMessageManager.d.ts

@@ -1,8 +1,8 @@
 import { IOManagerListener } from "./CfgIOManager.js";
 import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 /**
- * This class does nothing on it's own. It is used to coordinate sending and receiving
- * using the post message-API. See https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+ * This class is used to coordinate sending and receiving using the post message-API.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
  */
 export declare class CfgWindowMessageManager extends CfgWindowEventManager<"message", unknown> {
     private static _instance;

package/dist/io/CfgWindowMessageManager.js

@@ -1,8 +1,8 @@
 import { CfgIOManager } from "./CfgIOManager.js";
 import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 /**
- * This class does nothing on it's own. It is used to coordinate sending and receiving
- * using the post message-API. See https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+ * This class is used to coordinate sending and receiving using the post message-API.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
  */
 export class CfgWindowMessageManager extends CfgWindowEventManager {
     /**
@@ -64,6 +64,9 @@ export class CfgWindowMessageManager extends CfgWindowEventManager {
         return super.stopListenForMessage(l);
     }
     send(messageKey, data) {
+        if (this.receiveInProgress) {
+            return;
+        }
         const container = CfgIOManager.makeContainer({
             [messageKey]: data,
         });

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

@@ -1,4 +1,4 @@
-import { DtoConfProd } from "../CatalogueAPI.js";
+import { DtoProductConfiguration } from "../CatalogueAPI.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage, CfgProdConfMessageVersions } from "./CfgIOProdConfConnector.js";
 import { CfgWindowMessageManager } from "./CfgWindowMessageManager.js";
 /**
@@ -11,7 +11,8 @@ import { CfgWindowMessageManager } from "./CfgWindowMessageManager.js";
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export declare class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector<CfgProdConfMessage> {
-    constructor(manager: CfgWindowMessageManager, doValidate?: boolean, sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoConfProd, initial: boolean): CfgProdConfMessage;
+    private _sendVersions;
+    constructor(manager: CfgWindowMessageManager, doValidate?: boolean, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
+    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgProdConfMessage;
 }
 //# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -9,10 +9,11 @@ import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProd
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector {
-    constructor(manager, doValidate = true, sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
-        super(manager, doValidate, sendVersions, includeExtendedDataInSend, includeProdParamsInSend);
+    constructor(manager, doValidate = true, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, doValidate, includeExtendedDataInSend, includeProdParamsInSend);
+        this._sendVersions = _sendVersions;
     }
     makeSendData(conf, initial) {
-        return this.makeMessage(conf, initial);
+        return CfgIOProdConfConnector.makeMessage(conf, initial, this._sendVersions);
     }
 }

package/dist/productConfiguration/CfgFeature.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoConfFeature, DtoFeature, DtoSelectedOption, DtoSyncGroup, DtoSyncGroupMethods } from "../CatalogueAPI.js";
+import { DtoFeature, DtoFeatureConfiguration, DtoSelectedOption, DtoSyncGroup, DtoSyncGroupMethods } from "../CatalogueAPI.js";
 import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { SyncCode } from "../syncGroups/SyncGroupsHandler.js";
@@ -99,7 +99,7 @@ export declare class _CfgFeatureInternal {
      * as nonexisting children can not call their parent.
      */
     _childHasChanged: (childOption: _CfgOptionInternal, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
-    getDtoConf: (includeExtendedData: boolean) => DtoConfFeature;
+    getDtoConfiguration: (includeExtendedData: boolean) => DtoFeatureConfiguration;
     setApiSelection: (apiOptionSelectionMap: {
         [index: string]: DtoSelectedOption;
     } | undefined) => Promise<boolean>;

package/dist/productConfiguration/CfgFeature.js

@@ -114,7 +114,7 @@ export class _CfgFeatureInternal {
             }
             yield this._notifyAllOfChange(bubbleMode, committed);
         });
-        this.getDtoConf = (includeExtendedData) => {
+        this.getDtoConfiguration = (includeExtendedData) => {
             const result = {
                 code: this.code,
             };
@@ -124,7 +124,7 @@ export class _CfgFeatureInternal {
             }
             const selectedOptions = this._selectedOptions;
             if (0 < selectedOptions.length) {
-                result.options = selectedOptions.map((o) => o._internal.getDtoConf(includeExtendedData));
+                result.options = selectedOptions.map((o) => o._internal.getDtoConfiguration(includeExtendedData));
             }
             return result;
         };

package/dist/productConfiguration/CfgOption.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoConfOption, DtoFeature, DtoOption, DtoSelectedOption } from "../CatalogueAPI.js";
+import { DtoFeature, DtoOption, DtoOptionConfiguration, DtoSelectedOption } from "../CatalogueAPI.js";
 import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { NumericValuesSelection } from "../utilitiesNumericValues.js";
@@ -89,7 +89,7 @@ export declare class _CfgOptionInternal {
     get features(): CfgFeature[];
     /** Called by child to tell its parent that it has changed. */
     _childHasChanged: (freshRef: CfgFeature, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
-    getDtoConf: (includeExtendedData: boolean) => DtoConfOption;
+    getDtoConfiguration: (includeExtendedData: boolean) => DtoOptionConfiguration;
     setApiSelection: (apiOptionSelection: DtoSelectedOption | undefined) => Promise<boolean>;
     structureCompare: (other: _CfgOptionInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
     tryMatchSelection: (other: CfgOption, descriptionMatch?: boolean) => Promise<boolean>;

package/dist/productConfiguration/CfgOption.js

@@ -110,7 +110,7 @@ export class _CfgOptionInternal {
                 yield this.parent._childHasChanged(this, bubbleMode, committed);
             }
         });
-        this.getDtoConf = (includeExtendedData) => {
+        this.getDtoConfiguration = (includeExtendedData) => {
             const { features, isUseNumericValue, code, selected, numericValue } = this;
             if (!selected) {
                 throw new Error("Currently only useable on selected options. Selected in the result is for future use.");
@@ -128,7 +128,7 @@ export class _CfgOptionInternal {
                 }
             }
             if (0 < features.length) {
-                result.features = features.map((f) => f._internal.getDtoConf(includeExtendedData));
+                result.features = features.map((f) => f._internal.getDtoConfiguration(includeExtendedData));
             }
             return result;
         };

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, LengthValue, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoConfFeature, DtoFeature, DtoFeatureRef, DtoSelectedOption } from "../CatalogueAPI.js";
+import { DtoFeature, DtoFeatureConfiguration, DtoFeatureRef, DtoSelectedOption } from "../CatalogueAPI.js";
 import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgFeature, _CfgFeatureInternal } from "./CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./CfgOption.js";
@@ -34,7 +34,7 @@ export declare class _CfgProductConfigurationInternal {
     _freshRefDescendants(): void;
     /** Called by child to tell its parent that it has changed. */
     _childHasChanged: (freshRef: CfgFeature, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
-    getDtoConf: (includeExtendedData: boolean) => DtoConfFeature[];
+    getDtoConfiguration: (includeExtendedData: boolean) => DtoFeatureConfiguration[];
     /**
      * When used internally the notifications are taken care off by the caller, but if set from
      * outside we want notifications to bubble all the way to the root.

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { compareArrays, count, isEqualLength, isLengthUnit, Observable, toError, toLengthUnit, } from "@configura/web-utilities";
 import { CfgProduct } from "../CfgProduct.js";
-import { convertDtoConfFeaturesToSelOptions } from "../ConfigurationConverter.js";
+import { convertDtoFeatureConfigurationsToSelOptions } from "../ConfigurationConverter.js";
 import { CfgFeature } from "./CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 import { syncCfgFeatures } from "./utilitiesProductConfiguration.js";
@@ -55,7 +55,7 @@ export class _CfgProductConfigurationInternal {
             features[i] = freshRef;
             yield this._notifyAllOfChange(bubbleMode, committed);
         });
-        this.getDtoConf = (includeExtendedData) => this._features.map((f) => f._internal.getDtoConf(includeExtendedData));
+        this.getDtoConfiguration = (includeExtendedData) => this._features.map((f) => f._internal.getDtoConfiguration(includeExtendedData));
         /**
          * When used internally the notifications are taken care off by the caller, but if set from
          * outside we want notifications to bubble all the way to the root.
@@ -233,7 +233,7 @@ export class CfgProductConfiguration {
          */
         this.tryMatchSelection = (other, descriptionMatch = false // Match on case insensitive description, not code
         ) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.tryMatchSelection(other._internal, descriptionMatch, true); });
-        this.getApiSelection = () => convertDtoConfFeaturesToSelOptions(this._internal.getDtoConf(false), true);
+        this.getApiSelection = () => convertDtoFeatureConfigurationsToSelOptions(this._internal.getDtoConfiguration(false), true);
         /**
          * This method does not propagate its selections.
          * This method will not cause validation calls. Data is assumed to already be validated.

package/dist/productLoader.js

@@ -21,7 +21,7 @@ import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js"
  */
 export function wrapWithGetProductCache(getProduct) {
     const cache = new PromiseCache();
-    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params, params.partNumber), () => getProduct(params)); });
+    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params), () => getProduct(params)); });
 }
 /**
  * Wraps a postValidate function so that it caches for the time it lives.
@@ -37,7 +37,7 @@ export function wrapWithGetProductCache(getProduct) {
 export function wrapWithPostValidateCache(postValidate) {
     const cache = new PromiseCache();
     return (params, body) => __awaiter(this, void 0, void 0, function* () {
-        return cache.get(`${makeProductKey(params, params.partNumber)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
+        return cache.get(`${makeProductKey(params)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
     });
 }
 /** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */

package/dist/utilitiesCatalogueData.d.ts

@@ -1,6 +1,15 @@
 import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithLang, DtoCatalogueParamsWithoutCid, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParams, DtoProductParamsWithLang, 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 makeProductKey: (cat: DtoCatalogueParams, pKey: string) => 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;
+/**
+ * Makes a string from selected options, can be used as a key for a selection.
+ */
 export declare const makeSelOptionsKey: (options: DtoSelectedOption[]) => string;
 export declare type RootNodeSource = DtoModel | File;
 export declare type CfgProductData = Omit<Omit<DtoProductData, "models">, "partsData"> & {

package/dist/utilitiesCatalogueData.js

@@ -1,6 +1,15 @@
 import { shallowCompareDictionaries } from "@configura/web-utilities";
+/**
+ * Makes a string from the params which can be used as a key in for example React. Language is not respected.
+ */
 export const makeCatalogueKey = (cat) => `${cat.cid}-${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
-export const makeProductKey = (cat, pKey) => `${makeCatalogueKey(cat)}-${pKey}`;
+/**
+ * Makes a string from the params which can be used as a key in for example React. Language is not respected.
+ */
+export const makeProductKey = (prod) => `${makeCatalogueKey(prod)}-${prod.partNumber}`;
+/**
+ * Makes a string from selected options, can be used as a key for a selection.
+ */
 export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
     var _a;
     const { code, numericValue, next } = option;

package/dist/utilitiesCataloguePermission.d.ts

@@ -4,14 +4,20 @@ interface CataloguePermissionByEnterpriseKey {
 }
 export declare const groupAndSortCataloguePermissions: (cataloguePermissions: DtoCataloguePermission[]) => CataloguePermissionByEnterpriseKey;
 export declare const isParamSet: (param: string | undefined) => boolean;
-export declare const createCataloguePermissionsFilter: (cid: number | undefined, enterprise: string | undefined, prdCat: string | undefined, prdCatVersion: string | undefined, priceList: string | undefined, vendor: string | undefined) => (perm: DtoCataloguePermission) => boolean;
+export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParams>) => (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
  * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
  * string compare.
  */
-export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: DtoCataloguePermission[], cid: number | undefined, enterprise: string | undefined, prdCat: string | undefined, priceList: string | undefined, vendor: string | undefined) => string | undefined;
+export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: DtoCataloguePermission[], catParams: {
+    cid: number | undefined;
+    enterprise: string | undefined;
+    prdCat: string | undefined;
+    priceList: string | undefined;
+    vendor: string | undefined;
+}) => string | undefined;
 /**
  * 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 catalogue

package/dist/utilitiesCataloguePermission.js

@@ -15,24 +15,27 @@ export const groupAndSortCataloguePermissions = (cataloguePermissions) => {
     return cataloguePermissionByEnterpriseKey;
 };
 export const isParamSet = (param) => param !== undefined && param !== "" && param !== "-";
-export const createCataloguePermissionsFilter = (cid, enterprise, prdCat, prdCatVersion, priceList, vendor) => (perm) => (cid === undefined || cid === perm.cid) &&
-    (!isParamSet(enterprise) || enterprise === perm.enterprise) &&
-    (!isParamSet(prdCat) || prdCat === perm.prdCat) &&
-    (!isParamSet(prdCatVersion) || prdCatVersion === perm.prdCatVersion) &&
-    (!isParamSet(vendor) ||
-        perm.vendors === undefined ||
-        perm.vendors.some((v) => vendor === v)) &&
-    (!isParamSet(priceList) ||
-        perm.priceLists === undefined ||
-        perm.priceLists.some((p) => priceList === p));
+export const createCataloguePermissionsFilter = (catParams) => {
+    const { cid, enterprise, prdCat, prdCatVersion, vendor, priceList } = catParams;
+    return (perm) => (cid === undefined || cid === perm.cid) &&
+        (!isParamSet(enterprise) || enterprise === perm.enterprise) &&
+        (!isParamSet(prdCat) || prdCat === perm.prdCat) &&
+        (!isParamSet(prdCatVersion) || prdCatVersion === perm.prdCatVersion) &&
+        (!isParamSet(vendor) ||
+            perm.vendors === undefined ||
+            perm.vendors.some((v) => vendor === v)) &&
+        (!isParamSet(priceList) ||
+            perm.priceLists === undefined ||
+            perm.priceLists.some((p) => priceList === p));
+};
 /**
  * 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
  * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
  * string compare.
  */
-export const getPrdCatVersionFromPermissions = (cataloguePermissions, cid, enterprise, prdCat, priceList, vendor) => {
-    const filter = createCataloguePermissionsFilter(cid, enterprise, prdCat, "-", priceList, vendor);
+export const getPrdCatVersionFromPermissions = (cataloguePermissions, catParams) => {
+    const filter = createCataloguePermissionsFilter(Object.assign(Object.assign({}, catParams), { prdCatVersion: undefined }));
     const applicablePermissions = cataloguePermissions.filter(filter);
     return applicablePermissions.reduce((pVersion, c) => {
         const cVersion = c.prdCatVersion;
@@ -55,11 +58,11 @@ export const getPrdCatVersionFromPermissions = (cataloguePermissions, cid, enter
  * @param params
  */
 export const getPrdCatVersionOrLatestFromPermissions = (params, cataloguePermissions) => {
-    const { cid, enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
+    const { prdCatVersion } = params;
     if (isParamSet(prdCatVersion)) {
         return prdCatVersion;
     }
-    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, cid, enterprise, prdCat, priceList, vendor);
+    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, params);
     if (highestFoundVersion === undefined) {
         return prdCatVersion;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/web-api",
-	"version": "2.0.0-alpha.1",
+	"version": "2.0.0-alpha.12",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "2.0.0-alpha.1"
+		"@configura/web-utilities": "2.0.0-alpha.12"
 	},
-	"gitHead": "f35367369c2e0189ed8181ae91040a149c729368"
+	"gitHead": "82ffe4d0ec20d169b4e7ddb94b8207b6aa7d62a2"
 }