@configura/web-api 2.0.0-alpha.14 → 2.0.0-alpha.17

package/dist/io/CfgHistoryManager.js

@@ -1,6 +1,22 @@
-import { mapQueryString, unmapQueryString } from "@configura/web-utilities";
+import { mapQueryString, Observable, unmapQueryString } from "@configura/web-utilities";
 import { CfgIOManager } from "./CfgIOManager.js";
 import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
+/**
+ * How the history is updated.
+ * @param DoNotWrite Only listens to initial URL-values.
+ * @param Replace Replaces the current history frame at updates.
+ * @param Push Adds history frames at updates.
+ * @param ReplaceAndUpdateUrl Replaces the current history frame at updates and updates the browser URL
+ * @param PushAndUpdateUrl Adds history frames at updates and updates the browser URL
+ */
+export var HistoryMode;
+(function (HistoryMode) {
+    HistoryMode[HistoryMode["DoNotWrite"] = 0] = "DoNotWrite";
+    HistoryMode[HistoryMode["Replace"] = 1] = "Replace";
+    HistoryMode[HistoryMode["Push"] = 2] = "Push";
+    HistoryMode[HistoryMode["ReplaceAndUpdateUrl"] = 3] = "ReplaceAndUpdateUrl";
+    HistoryMode[HistoryMode["PushAndUpdateUrl"] = 4] = "PushAndUpdateUrl";
+})(HistoryMode || (HistoryMode = {}));
 /**
  * This class is used to coordinate writing and reading to the browser history.
  * It handles messages sent from the connectors.
@@ -8,6 +24,8 @@ import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 export class CfgHistoryManager extends CfgWindowEventManager {
     constructor() {
         super();
+        this._aggregatedQsKeyValues = new Map();
+        this._urlUpdateObservable = new Observable();
         this.eventType = "popstate";
     }
     static get instance() {
@@ -16,22 +34,62 @@ export class CfgHistoryManager extends CfgWindowEventManager {
         }
         return this._instance;
     }
+    /**
+     * @returns The current browser URL updated with the latest updates from
+     *          the Connectors.
+     */
+    getUrl() {
+        return CfgHistoryManager._makeUpdatedUrl(this._aggregatedQsKeyValues);
+    }
+    /**
+     * Listen for updated URL:s. This doesn't have to mean the URL in the
+     * browser has been updated.
+     */
+    listenForUrl(listener) {
+        this._urlUpdateObservable.listen(listener);
+    }
+    /**
+     * Stop listen.
+     */
+    stopListenForUrl(listener) {
+        this._urlUpdateObservable.stopListen(listener);
+    }
     /**
      * Write to the history
      */
     send(messageKey, data) {
-        const { qsKeyValues, message, useHistoryPush } = data;
+        const { qsKeyValues, message, mode } = data;
+        const warnings = this.getWarnings();
+        if (warnings.length !== 0) {
+            console.warn("History updating blocked by warnings");
+            warnings.forEach((w) => console.warn(w));
+            return;
+        }
+        for (const keyValue of qsKeyValues) {
+            this._aggregatedQsKeyValues.set(keyValue[0], keyValue[1]);
+        }
+        this._urlUpdateObservable.notifyAll(this.getUrl());
+        if (mode === HistoryMode.DoNotWrite) {
+            return;
+        }
         // Initial data is before user interaction has happened
         const initial = message.initial;
+        const url = CfgHistoryManager._makeUpdatedUrl(qsKeyValues);
         // At initial we do not replace the URL as we presumable have the defaults
-        const newUrl = initial ? null : CfgHistoryManager._makeUpdatedUrl(qsKeyValues);
+        const writeUrl = initial ||
+            !(mode === HistoryMode.PushAndUpdateUrl || mode === HistoryMode.ReplaceAndUpdateUrl)
+            ? null
+            : url;
         // ...but we do replace the state so that we can in the future browse back to here
         const newState = CfgHistoryManager._makeUpdatedState(window.history.state, message, messageKey);
-        if (initial || !useHistoryPush || this.receiveInProgress) {
-            window.history.replaceState(newState, "", newUrl);
+        if (initial ||
+            mode === HistoryMode.Replace ||
+            mode === HistoryMode.ReplaceAndUpdateUrl ||
+            this.receiveInProgress) {
+            window.history.replaceState(newState, "", writeUrl);
         }
         else {
-            window.history.pushState(newState, "", newUrl);
+            window.history.pushState(newState, "", writeUrl);
         }
     }
     /**
@@ -79,4 +137,14 @@ export class CfgHistoryManager extends CfgWindowEventManager {
     getDataFromEvent(event) {
         return event.state;
     }
+    static getMessageFromCurrentHistoryState(messageKey) {
+        const state = window.history.state;
+        if (!CfgIOManager.isIOContainer(state)) {
+            return undefined;
+        }
+        if (!CfgIOManager.hasIOContainerMessageKey(state, messageKey)) {
+            return undefined;
+        }
+        return CfgIOManager.getMessageFromIOContainer(state, messageKey);
+    }
 }

package/dist/io/CfgHistoryToProdConfConnector.d.ts

@@ -1,19 +1,18 @@
-import { DtoProductConfiguration } from "../CatalogueAPI.js";
-import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
+import { DtoProductConf } from "../CatalogueAPI.js";
+import { CfgHistoryManager, CfgHistoryManagerSendData, HistoryMode } from "./CfgHistoryManager.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
 /**
  * Instantiating this will make the browser history (and URL) update with the product configuration.
  */
 export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector<CfgHistoryManagerSendData<CfgProdConfMessage>> {
-    private readonly _useHistoryPush;
+    private readonly _mode;
     private readonly _qsKey;
     /**
-     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     * @param _mode
      * @param _qsKey The Query String key for product configuration.
-     * @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(): DtoProductConfiguration | undefined;
-    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
+    constructor(manager: CfgHistoryManager, _mode: HistoryMode, _qsKey?: string);
+    protected getInitialProdConf(): DtoProductConf | undefined;
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
 }
 //# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -1,26 +1,39 @@
-import { compactStringToDtoProductConfiguration, dtoProductConfigurationToCompactString, } from "../ConfigurationConverter.js";
+import { augmentErrorMessage } from "@configura/web-utilities";
+import { compactStringToDtoProductConf, dtoProductConfigurationToCompactString, } from "../ConfigurationConverter.js";
 import { CfgHistoryManager } from "./CfgHistoryManager.js";
-import { CfgIOProdConfConnector, CfgProdConfMessageVersions, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, getHighestVersionProdConfMessage, isCfgProdConfMessageV2, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
 /**
  * Instantiating this will make the browser history (and URL) update with the product configuration.
  */
 export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
     /**
-     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     * @param _mode
      * @param _qsKey The Query String key for product configuration.
-     * @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, false, false);
-        this._useHistoryPush = _useHistoryPush;
+    constructor(manager, _mode, _qsKey = STAGE_PROD_CONF_MESSAGE_KEY) {
+        super(manager, false, false);
+        this._mode = _mode;
         this._qsKey = _qsKey;
     }
     getInitialProdConf() {
-        const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
-        if (s === undefined) {
-            return undefined;
+        // First try to use the state, if that doesn't work use the query string
+        const initialMessage = CfgHistoryManager.getMessageFromCurrentHistoryState(STAGE_PROD_CONF_MESSAGE_KEY);
+        if (initialMessage !== undefined) {
+            const highestVersionMessage = getHighestVersionProdConfMessage(initialMessage.subMessages);
+            if (isCfgProdConfMessageV2(highestVersionMessage)) {
+                return highestVersionMessage.conf;
+            }
+        }
+        try {
+            const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
+            if (s === undefined) {
+                return undefined;
+            }
+            return compactStringToDtoProductConf(s);
+        }
+        catch (err) {
+            throw augmentErrorMessage(err, "Failed read configuration from query string");
         }
-        return compactStringToDtoProductConfiguration(s);
     }
     makeSendData(conf, initial) {
         return {
@@ -28,7 +41,7 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
             qsKeyValues: new Map([
                 [STAGE_PROD_CONF_MESSAGE_KEY, dtoProductConfigurationToCompactString(conf)],
             ]),
-            useHistoryPush: this._useHistoryPush,
+            mode: this._mode,
         };
     }
 }

package/dist/io/CfgIOManager.d.ts

@@ -1,3 +1,4 @@
+import { CfgIOWarningSupplier } from "./CfgIOWarningSupplier";
 declare type ConfiguraAttribute = "C0nf1gura";
 declare type ConfiguraShebang = "arug1fn0C";
 declare const CONFIGURA_ATTRIBUTE: ConfiguraAttribute;
@@ -17,6 +18,10 @@ export declare type CfgIOContainer = {
  * Base class for classes handling input and output in globally shared environments.
  */
 export declare abstract class CfgIOManager<S> {
+    private _warningSuppliers;
+    addWarningSupplier(supplier: CfgIOWarningSupplier): void;
+    removeWarningSupplier(supplier: CfgIOWarningSupplier): void;
+    getWarnings(): string[];
     /**
      * Listen for the message messageKey being received.
      */

package/dist/io/CfgIOManager.js

@@ -18,12 +18,31 @@ const hasConfiguraAttribute = (data) => {
  */
 export class CfgIOManager {
     constructor() {
+        this._warningSuppliers = [];
         // A lock to avoid circular write. Asynchronous conditions can make this not be enough.
         // Avoid creating pre-conditions where this can happen.
         this._receiveInProgress = false;
         this._messageListeners = [];
         this._getIndexOfMessageListener = (l) => this._messageListeners.findIndex((item) => l === item.l);
     }
+    addWarningSupplier(supplier) {
+        this._warningSuppliers.push(supplier);
+    }
+    removeWarningSupplier(supplier) {
+        const i = this._warningSuppliers.indexOf(supplier);
+        if (i === -1) {
+            return;
+        }
+        this._warningSuppliers.splice(i, 1);
+    }
+    getWarnings() {
+        return this._warningSuppliers.reduce((aggregated, supplier) => {
+            for (const warning of supplier.getWarnings()) {
+                aggregated.push(warning);
+            }
+            return aggregated;
+        }, []);
+    }
     /**
      * Listen for the message messageKey being received.
      */
@@ -81,7 +100,7 @@ export class CfgIOManager {
                     if (item.messageKey !== messageKey) {
                         continue;
                     }
-                    // async, not waiting. Might need to change.
+                    // async, not waiting on each other. Might need to change.
                     promises.push(item.l(message));
                 }
             }

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -1,6 +1,7 @@
-import { DtoAdditionalProductConfiguration, DtoProductConfiguration } from "../CatalogueAPI.js";
+import { DtoAdditionalProductConfiguration, DtoProductConf } from "../CatalogueAPI.js";
 import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
 import { CfgIOManager } from "./CfgIOManager.js";
+import { CfgIOWarningSupplier } from "./CfgIOWarningSupplier.js";
 export declare const isCfgProdConfMessage: (data: unknown) => data is CfgProdConfMessageV1 | CfgProdConfMessageV2;
 export declare type CfgProdConfMessageV1 = {
     version: "1.0";
@@ -9,7 +10,7 @@ export declare type CfgProdConfMessageV1 = {
 export declare const isCfgProdConfMessageV1: (data: unknown) => data is CfgProdConfMessageV1;
 export declare type CfgProdConfMessageV2 = {
     version: "2.0";
-    conf: DtoProductConfiguration;
+    conf: DtoProductConf;
 };
 export declare const isCfgProdConfMessageV2: (data: unknown) => data is CfgProdConfMessageV2;
 export declare type CfgProdConfMessage = {
@@ -23,26 +24,26 @@ export declare enum CfgProdConfMessageVersions {
 }
 export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
 declare type ProdConfMessageCallback = (message: CfgProdConfMessage) => Promise<void>;
-declare type ProdConfCallback = (conf: DtoProductConfiguration) => Promise<void>;
+declare type ProdConfCallback = (conf: DtoProductConf) => 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;
+export declare abstract class CfgIOProdConfConnector<S> implements CfgIOWarningSupplier {
+    protected readonly _ioManager: CfgIOManager<S>;
     private readonly _includeExtendedDataInSend;
     private readonly _includeProdParamsInSend;
-    private _product;
+    protected _product: CfgProduct | undefined;
     private _stopListenToMessage;
     private _stopListenToProdConf;
-    constructor(_ioManager: CfgIOManager<S>, _doValidate: boolean, _includeExtendedDataInSend: boolean, // Only v2.0
+    constructor(_ioManager: CfgIOManager<S>, _includeExtendedDataInSend: boolean, // Only for v2.0
     _includeProdParamsInSend: boolean);
-    destroy: () => void;
+    destroy(): void;
+    getWarnings(): string[];
     setProduct: (product: CfgProduct | undefined) => Promise<void>;
     private _send;
-    protected getInitialProdConf(): DtoProductConfiguration | undefined;
-    protected abstract makeSendData(conf: DtoProductConfiguration, initial: boolean): S;
-    static makeMessage(conf: DtoProductConfiguration, initial: boolean, sendVersions: CfgProdConfMessageVersions): CfgProdConfMessage;
+    protected getInitialProdConf(): DtoProductConf | undefined;
+    protected abstract makeSendData(conf: DtoProductConf, initial: boolean): S;
+    static makeMessage(conf: DtoProductConf, initial: boolean, sendVersions: CfgProdConfMessageVersions): CfgProdConfMessage;
     static makeMessageListener(callback: ProdConfMessageCallback): (message: unknown) => Promise<void>;
     /**
      * Register the callback to listen for Product Configuration messages

package/dist/io/CfgIOProdConfConnector.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { convertDtoProductConfigurationToV1 } from "../ConfigurationConverter.js";
+import { convertDtoProductConfToV1 } 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";
@@ -24,20 +24,14 @@ 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, _includeExtendedDataInSend, // Only v2.0
-    _includeProdParamsInSend // Only v2.0
+    constructor(_ioManager, _includeExtendedDataInSend, // Only for v2.0
+    _includeProdParamsInSend // Only for v2.0
     ) {
         this._ioManager = _ioManager;
-        this._doValidate = _doValidate;
         this._includeExtendedDataInSend = _includeExtendedDataInSend;
         this._includeProdParamsInSend = _includeProdParamsInSend;
         this._stopListenToMessage = undefined;
         this._stopListenToProdConf = undefined;
-        this.destroy = () => {
-            var _a, _b;
-            (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
-            (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
-        };
         this.setProduct = (product) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const currentProduct = this._product;
@@ -58,12 +52,17 @@ export class CfgIOProdConfConnector {
             }
             // We only try to load initial configuration at first load
             if (currentProduct === undefined) {
-                const initialProdConf = this.getInitialProdConf();
-                if (initialProdConf !== undefined) {
-                    yield newProduct.setDtoConfiguration(initialProdConf, this._doValidate);
+                try {
+                    const initialProdConf = this.getInitialProdConf();
+                    if (initialProdConf !== undefined) {
+                        yield newProduct.setDtoConf(initialProdConf);
+                    }
+                }
+                catch (err) {
+                    console.error(err);
                 }
             }
-            this._send(this.makeSendData(newProduct.getDtoConfiguration(this._includeExtendedDataInSend, this._includeProdParamsInSend), true));
+            this._send(this.makeSendData(newProduct.getDtoConf(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) {
@@ -72,11 +71,11 @@ export class CfgIOProdConfConnector {
                 }
                 const highestVersionMessage = getHighestVersionProdConfMessage(subMessages);
                 if (isCfgProdConfMessageV1(highestVersionMessage)) {
-                    yield newProduct.setApiSelection(highestVersionMessage.conf, this._doValidate);
+                    yield newProduct.setApiSelection(highestVersionMessage.conf);
                     return;
                 }
                 if (isCfgProdConfMessageV2(highestVersionMessage)) {
-                    yield newProduct.setDtoConfiguration(highestVersionMessage.conf, this._doValidate);
+                    yield newProduct.setDtoConf(highestVersionMessage.conf);
                     return;
                 }
                 throw new Error("Unknown message version");
@@ -84,6 +83,22 @@ export class CfgIOProdConfConnector {
             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);
+        _ioManager.addWarningSupplier(this);
+    }
+    destroy() {
+        var _a, _b;
+        (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
+        (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
+        this._ioManager.removeWarningSupplier(this);
+    }
+    getWarnings() {
+        const product = this._product;
+        if (product !== undefined && product.hasRootFeaturesChanged) {
+            return [
+                "In at least one of the Products, Functional Selection has taken place, thereby changing what root Features are used. The SDK can not yet apply a serialized configuration in these cases. Extracting this data from the SDK for external applications can work, but reinserting the data into Stage will most likely fail.",
+            ];
+        }
+        return [];
     }
     getInitialProdConf() {
         return undefined;
@@ -94,7 +109,7 @@ export class CfgIOProdConfConnector {
             CfgProdConfMessageVersions.V1dot0) {
             const v1 = {
                 version: "1.0",
-                conf: convertDtoProductConfigurationToV1(conf, true),
+                conf: convertDtoProductConfToV1(conf, true),
             };
             result.push(v1);
         }
@@ -130,7 +145,7 @@ export class CfgIOProdConfConnector {
             if (!n.committed) {
                 return;
             }
-            callback(n.freshRef.getDtoConfiguration(includeExtendedDataInSend, includeProdParamsInSend));
+            callback(n.freshRef.getDtoConf(includeExtendedDataInSend, includeProdParamsInSend));
         };
     }
     static listenForProdConf(product, callback, includeExtendedDataInSend, includeProdParamsInSend) {

package/dist/io/CfgIOWarningSupplier.d.ts

@@ -0,0 +1,4 @@
+export interface CfgIOWarningSupplier {
+    getWarnings(): string[];
+}
+//# sourceMappingURL=CfgIOWarningSupplier.d.ts.map

package/dist/io/CfgIOWarningSupplier.js

@@ -0,0 +1 @@
+export {};

package/dist/io/CfgObservableStateToProdConfConnector.d.ts

@@ -1,16 +1,15 @@
-import { DtoProductConfiguration } from "../CatalogueAPI.js";
+import { DtoProductConf } from "../CatalogueAPI.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage, CfgProdConfMessageVersions } from "./CfgIOProdConfConnector.js";
 import { CfgObservableStateManager } from "./CfgObservableStateManager.js";
 /**
  * Instantiating this will make the observable state update with the product configuration.
- * @param doValidate Run server side product validation for incoming
  * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
  * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export declare class CfgObservableStateToProdConfConnector extends CfgIOProdConfConnector<CfgProdConfMessage> {
     private _sendVersions;
-    constructor(manager: CfgObservableStateManager, doValidate?: boolean, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgProdConfMessage;
+    constructor(manager: CfgObservableStateManager, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgProdConfMessage;
 }
 //# sourceMappingURL=CfgObservableStateToProdConfConnector.d.ts.map

package/dist/io/CfgObservableStateToProdConfConnector.js

@@ -1,14 +1,13 @@
 import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProdConfConnector.js";
 /**
  * Instantiating this will make the observable state update with the product configuration.
- * @param doValidate Run server side product validation for incoming
  * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
  * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
  * @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, includeExtendedDataInSend, includeProdParamsInSend);
+    constructor(manager, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, includeExtendedDataInSend, includeProdParamsInSend);
         this._sendVersions = _sendVersions;
     }
     makeSendData(conf, initial) {

package/dist/io/CfgWindowMessageManager.js

@@ -70,6 +70,10 @@ export class CfgWindowMessageManager extends CfgWindowEventManager {
         const container = CfgIOManager.makeContainer({
             [messageKey]: data,
         });
+        const warnings = this.getWarnings();
+        if (warnings.length !== 0) {
+            warnings.forEach((w) => console.warn(w));
+        }
         for (const remoteEnd of this._remoteEnds) {
             remoteEnd.postMessage(container, this._targetOrigin);
         }

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

@@ -1,18 +1,17 @@
-import { DtoProductConfiguration } from "../CatalogueAPI.js";
+import { DtoProductConf } from "../CatalogueAPI.js";
 import { CfgIOProdConfConnector, CfgProdConfMessage, CfgProdConfMessageVersions } from "./CfgIOProdConfConnector.js";
 import { CfgWindowMessageManager } from "./CfgWindowMessageManager.js";
 /**
  * Instantiating this will make Stage send product configuration changes using the post message-API.
  * It will also make Stage listen for incoming product configuration update messages.
  * This can be used to communicate in and out of an iframe for example.
- * @param doValidate Run server side product validation for incoming
  * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
  * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
  * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
  */
 export declare class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector<CfgProdConfMessage> {
     private _sendVersions;
-    constructor(manager: CfgWindowMessageManager, doValidate?: boolean, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoProductConfiguration, initial: boolean): CfgProdConfMessage;
+    constructor(manager: CfgWindowMessageManager, _sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgProdConfMessage;
 }
 //# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -3,14 +3,13 @@ import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProd
  * Instantiating this will make Stage send product configuration changes using the post message-API.
  * It will also make Stage listen for incoming product configuration update messages.
  * This can be used to communicate in and out of an iframe for example.
- * @param doValidate Run server side product validation for incoming
  * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
  * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
  * @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, includeExtendedDataInSend, includeProdParamsInSend);
+    constructor(manager, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, includeExtendedDataInSend, includeProdParamsInSend);
         this._sendVersions = _sendVersions;
     }
     makeSendData(conf, initial) {

package/dist/productConfiguration/CfgFeature.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoFeature, DtoFeatureConfiguration, DtoSelectedOption, DtoSyncGroup, DtoSyncGroupMethods } from "../CatalogueAPI.js";
+import { DtoFeature, DtoFeatureConf, 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>;
-    getDtoConfiguration: (includeExtendedData: boolean) => DtoFeatureConfiguration;
+    getDtoConf: (includeExtendedData: boolean) => DtoFeatureConf;
     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.getDtoConfiguration = (includeExtendedData) => {
+        this.getDtoConf = (includeExtendedData) => {
             const result = {
                 code: this.code,
             };
@@ -124,10 +124,16 @@ export class _CfgFeatureInternal {
             }
             const selectedOptions = this._selectedOptions;
             if (0 < selectedOptions.length) {
-                result.options = selectedOptions.map((o) => o._internal.getDtoConfiguration(includeExtendedData));
+                result.options = selectedOptions.map((o) => o._internal.getDtoConf(includeExtendedData));
             }
             return result;
         };
+        // DtoFeatureConf is the newer more easily readable format for configuration. As
+        // the API:s are still using the older format (and will for the forseeable future) we need
+        // to support both formats. The new format can be converted to the old, but not the other
+        // way around. For that reason the get-method above uses the new format, and the set-method
+        // below the old format. As these functions are meant to only be used internally this should't
+        // cause too much confusion.
         this.setApiSelection = (apiOptionSelectionMap) => __awaiter(this, void 0, void 0, function* () {
             const selectionType = this.selectionType;
             const isGroup = selectionType === SelectionType.Group;

package/dist/productConfiguration/CfgOption.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { DtoFeature, DtoOption, DtoOptionConfiguration, DtoSelectedOption } from "../CatalogueAPI.js";
+import { DtoFeature, DtoOption, DtoOptionConf, 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>;
-    getDtoConfiguration: (includeExtendedData: boolean) => DtoOptionConfiguration;
+    getDtoConf: (includeExtendedData: boolean) => DtoOptionConf;
     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.getDtoConfiguration = (includeExtendedData) => {
+        this.getDtoConf = (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,10 +128,16 @@ export class _CfgOptionInternal {
                 }
             }
             if (0 < features.length) {
-                result.features = features.map((f) => f._internal.getDtoConfiguration(includeExtendedData));
+                result.features = features.map((f) => f._internal.getDtoConf(includeExtendedData));
             }
             return result;
         };
+        // DtoOptionConf is the newer more easily readable format for configuration. As
+        // the API:s are still using the older format (and will for the forseeable future) we need
+        // to support both formats. The new format can be converted to the old, but not the other
+        // way around. For that reason the get-method above uses the new format, and the set-method
+        // below the old format. As these functions are meant to only be used internally this should't
+        // cause too much confusion.
         this.setApiSelection = (apiOptionSelection) => __awaiter(this, void 0, void 0, function* () {
             let features;
             if (apiOptionSelection === undefined) {