@configura/web-api 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/io/CfgHistoryManager.js

@@ -1,13 +1,31 @@
-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";
 /**
- * This class does nothing on it's own. It is used to coordinate writing to the history, that
- * is, updating the browsing history.
+ * 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.
  */
 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,21 +1,18 @@
-import { DtoConfProd } 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";
-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.
  */
 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(): DtoConfProd | undefined;
-    protected makeSendData(conf: DtoConfProd, 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,56 +1,47 @@
+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";
-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);
-}
+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, CfgProdConfMessageVersions.V2dot0, 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 stringToDtoConf(s);
     }
     makeSendData(conf, initial) {
         return {
-            message: this.makeMessage(conf, initial),
-            qsKeyValues: new Map([[STAGE_PROD_CONF_MESSAGE_KEY, dtoConfToString(conf)]]),
-            useHistoryPush: this._useHistoryPush,
+            message: CfgIOProdConfConnector.makeMessage(conf, initial, CfgProdConfMessageVersions.V2dot0),
+            qsKeyValues: new Map([
+                [STAGE_PROD_CONF_MESSAGE_KEY, dtoProductConfigurationToCompactString(conf)],
+            ]),
+            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,53 +1,57 @@
-import { DtoAdditionalProductConfiguration, DtoConfProd } 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";
     conf: DtoAdditionalProductConfiguration;
 };
+export declare const isCfgProdConfMessageV1: (data: unknown) => data is CfgProdConfMessageV1;
 export declare type CfgProdConfMessageV2 = {
     version: "2.0";
-    conf: DtoConfProd;
+    conf: DtoProductConf;
 };
+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: 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;
-    private readonly _sendVersions;
+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, _sendVersions: CfgProdConfMessageVersions, _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(): 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(): 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
      * @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 { 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";
+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,21 +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, _sendVersions, _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._sendVersions = _sendVersions;
         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;
@@ -53,49 +52,68 @@ 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.setDtoConf(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.getDtoConf(this._includeExtendedDataInSend, this._includeProdParamsInSend), true));
-            this._stopListenToMessage = this.listenForMessage((messages) => __awaiter(this, void 0, void 0, function* () {
+            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);
+                    return;
+                }
+                if (isCfgProdConfMessageV2(highestVersionMessage)) {
+                    yield newProduct.setDtoConf(highestVersionMessage.conf);
+                    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);
+        _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;
     }
-    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: convertDtoProductConfToV1(conf, true),
             };
             result.push(v1);
         }
-        if ((this._sendVersions & CfgProdConfMessageVersions.V2dot0) ===
+        if ((sendVersions & CfgProdConfMessageVersions.V2dot0) ===
             CfgProdConfMessageVersions.V2dot0) {
             const v2 = {
                 version: "2.0",
@@ -105,7 +123,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 +133,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.getDtoConf(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/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/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,15 +1,15 @@
-import { DtoConfProd } 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> {
-    constructor(manager: CfgObservableStateManager, doValidate?: boolean, sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoConfProd, initial: boolean): CfgProdConfMessage;
+    private _sendVersions;
+    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,16 +1,16 @@
 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, sendVersions, includeExtendedDataInSend, includeProdParamsInSend);
+    constructor(manager, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, 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,9 +64,16 @@ export class CfgWindowMessageManager extends CfgWindowEventManager {
         return super.stopListenForMessage(l);
     }
     send(messageKey, data) {
+        if (this.receiveInProgress) {
+            return;
+        }
         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);
         }