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

package/dist/io/CfgHistoryManager.d.ts

@@ -2,6 +2,21 @@ import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 declare type CfgHistoryManagerMessageData = {
     initial: boolean;
 };
+/**
+ * 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 declare enum HistoryMode {
+    DoNotWrite = 0,
+    Replace = 1,
+    Push = 2,
+    ReplaceAndUpdateUrl = 3,
+    PushAndUpdateUrl = 4
+}
 /**
  * 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 query string
@@ -11,7 +26,7 @@ declare type CfgHistoryManagerMessageData = {
  */
 export declare type CfgHistoryManagerSendData<D> = {
     message: D;
-    useHistoryPush: boolean;
+    mode: HistoryMode;
     qsKeyValues: Map<string, string | undefined>;
 };
 /**
@@ -22,6 +37,22 @@ export declare class CfgHistoryManager extends CfgWindowEventManager<"popstate",
     private static _instance;
     static get instance(): CfgHistoryManager;
     private constructor();
+    private _aggregatedQsKeyValues;
+    private _urlUpdateObservable;
+    /**
+     * @returns The current browser URL updated with the latest updates from
+     *          the Connectors.
+     */
+    getUrl(): string;
+    /**
+     * Listen for updated URL:s. This doesn't have to mean the URL in the
+     * browser has been updated.
+     */
+    listenForUrl(listener: (url: string) => void): void;
+    /**
+     * Stop listen.
+     */
+    stopListenForUrl(listener: (url: string) => void): void;
     /**
      * Write to the history
      */
@@ -47,6 +78,7 @@ export declare class CfgHistoryManager extends CfgWindowEventManager<"popstate",
     private static _makeUpdatedState;
     protected readonly eventType = "popstate";
     protected getDataFromEvent(event: PopStateEvent): unknown;
+    static getMessageFromCurrentHistoryState(messageKey: string): unknown | undefined;
 }
 export {};
 //# sourceMappingURL=CfgHistoryManager.d.ts.map

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,56 @@ 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;
+        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 +131,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,22 @@
-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";
-export declare function dtoConfToString(conf: DtoProductConfiguration): string;
-export declare function stringToDtoConf(conf: string): DtoProductConfiguration;
 /**
  * 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;
+    private static getInitialProdConf;
+    static make(manager: CfgHistoryManager, mode: HistoryMode, qsKey?: string): {
+        instance: CfgHistoryToProdConfConnector;
+        initial: DtoProductConf | undefined;
+    };
     /**
-     * @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>;
+    private constructor();
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
 }
 //# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -1,56 +1,50 @@
+import { augmentErrorMessage } from "@configura/web-utilities";
+import { CfgProdConfParts, compactStringToDtoProductConf, dtoProductConfigurationToCompactString, } from "../utilitiesConfiguration.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, false, false);
-        this._useHistoryPush = _useHistoryPush;
+    constructor(manager, _mode, _qsKey) {
+        super(manager, CfgProdConfParts.SyncGroupState);
+        this._mode = _mode;
         this._qsKey = _qsKey;
     }
-    getInitialProdConf() {
-        const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
-        if (s === undefined) {
-            return undefined;
+    static getInitialProdConf(qsKey) {
+        // 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(qsKey);
+            if (s === undefined) {
+                return undefined;
+            }
+            return compactStringToDtoProductConf(s);
         }
-        return stringToDtoConf(s);
+        catch (err) {
+            throw augmentErrorMessage(err, "Failed read configuration from query string");
+        }
+    }
+    static make(manager, mode, qsKey = STAGE_PROD_CONF_MESSAGE_KEY) {
+        const initial = this.getInitialProdConf(qsKey);
+        const instance = new CfgHistoryToProdConfConnector(manager, mode, qsKey);
+        return { instance, initial };
     }
     makeSendData(conf, initial) {
         return {
             message: CfgIOProdConfConnector.makeMessage(conf, initial, CfgProdConfMessageVersions.V2dot0),
-            qsKeyValues: new Map([[STAGE_PROD_CONF_MESSAGE_KEY, dtoConfToString(conf)]]),
-            useHistoryPush: this._useHistoryPush,
+            qsKeyValues: new Map([[this._qsKey, 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,6 +1,8 @@
-import { DtoAdditionalProductConfiguration, DtoProductConfiguration } from "../CatalogueAPI.js";
+import { DtoAdditionalProductConfiguration, DtoProductConf } from "../CatalogueAPI.js";
 import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
+import { CfgProdConfParts } from "../utilitiesConfiguration.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 +11,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,34 +25,31 @@ 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;
-    private readonly _includeExtendedDataInSend;
-    private readonly _includeProdParamsInSend;
-    private _product;
+export declare abstract class CfgIOProdConfConnector<S> implements CfgIOWarningSupplier {
+    protected readonly _ioManager: CfgIOManager<S>;
+    private readonly _includeInSend;
+    protected _product: CfgProduct | undefined;
     private _stopListenToMessage;
     private _stopListenToProdConf;
-    constructor(_ioManager: CfgIOManager<S>, _doValidate: boolean, _includeExtendedDataInSend: boolean, // Only v2.0
-    _includeProdParamsInSend: boolean);
-    destroy: () => void;
+    constructor(_ioManager: CfgIOManager<S>, _includeInSend: CfgProdConfParts);
+    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;
-    static makeMessageListener(callback: ProdConfMessageCallback): (message: unknown) => Promise<void>;
+    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
      */
     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;
+    static makeProdConfListener: (callback: ProdConfCallback, includeInSend: CfgProdConfParts) => (n: CfgProductChangeNotification) => void;
+    static listenForProdConf(product: CfgProduct, callback: ProdConfCallback, includeInSend: CfgProdConfParts): () => void;
 }
 export {};
 //# sourceMappingURL=CfgIOProdConfConnector.d.ts.map

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 { convertDtoConfProdToV1 } from "../ConfigurationConverter.js";
+import { convertDtoProductConfToV1 } from "../utilitiesConfiguration.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,12 @@ 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, _includeInSend // Only for v2.0
     ) {
         this._ioManager = _ioManager;
-        this._doValidate = _doValidate;
-        this._includeExtendedDataInSend = _includeExtendedDataInSend;
-        this._includeProdParamsInSend = _includeProdParamsInSend;
+        this._includeInSend = _includeInSend;
         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;
@@ -56,14 +48,7 @@ export class CfgIOProdConfConnector {
             if (newProduct === undefined) {
                 return;
             }
-            // 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);
-                }
-            }
-            this._send(this.makeSendData(newProduct.getDtoConf(this._includeExtendedDataInSend, this._includeProdParamsInSend), true));
+            this._send(this.makeSendData(newProduct.getDtoConf(this._includeInSend), true));
             this._stopListenToMessage = CfgIOProdConfConnector.listenForMessage((messages) => __awaiter(this, void 0, void 0, function* () {
                 const subMessages = messages.subMessages;
                 if (subMessages.length === 0) {
@@ -72,47 +57,34 @@ 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.setDtoConf(highestVersionMessage.conf, this._doValidate);
+                    yield newProduct.setDtoConf(highestVersionMessage.conf);
                     return;
                 }
                 throw new Error("Unknown message version");
             }), 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._stopListenToProdConf = CfgIOProdConfConnector.listenForProdConf(newProduct, (conf) => __awaiter(this, void 0, void 0, function* () { return this._send(this.makeSendData(conf, false)); }), this._includeInSend);
         });
         this._send = (data) => this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, data);
+        _ioManager.addWarningSupplier(this);
     }
-    getInitialProdConf() {
-        return undefined;
+    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);
     }
-    static makeMessage(conf, initial, sendVersions) {
-        const result = [];
-        if ((sendVersions & CfgProdConfMessageVersions.V1dot0) ===
-            CfgProdConfMessageVersions.V1dot0) {
-            const v1 = {
-                version: "1.0",
-                conf: convertDtoConfProdToV1(conf, true),
-            };
-            result.push(v1);
-        }
-        if ((sendVersions & CfgProdConfMessageVersions.V2dot0) ===
-            CfgProdConfMessageVersions.V2dot0) {
-            const v2 = {
-                version: "2.0",
-                conf,
-            };
-            result.push(v2);
+    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 { subMessages: result, initial };
-    }
-    static makeMessageListener(callback) {
-        return (message) => __awaiter(this, void 0, void 0, function* () {
-            const prodConfMessage = message;
-            yield callback(prodConfMessage);
-        });
+        return [];
     }
     /**
      * Register the callback to listen for Product Configuration messages
@@ -125,19 +97,41 @@ export class CfgIOProdConfConnector {
             ioManager.stopListenForMessage(listener);
         };
     }
-    static makeProdConfListener(callback, includeExtendedDataInSend, includeProdParamsInSend) {
-        return (n) => {
-            if (!n.committed) {
-                return;
-            }
-            callback(n.freshRef.getDtoConf(includeExtendedDataInSend, includeProdParamsInSend));
-        };
-    }
-    static listenForProdConf(product, callback, includeExtendedDataInSend, includeProdParamsInSend) {
-        const listener = this.makeProdConfListener(callback, includeExtendedDataInSend, includeProdParamsInSend);
+    static listenForProdConf(product, callback, includeInSend) {
+        const listener = this.makeProdConfListener(callback, includeInSend);
         product.listenForChange(listener);
         return () => {
             product.stopListenForChange(listener);
         };
     }
 }
+CfgIOProdConfConnector.makeMessage = (conf, initial, sendVersions) => {
+    const result = [];
+    if ((sendVersions & CfgProdConfMessageVersions.V1dot0) ===
+        CfgProdConfMessageVersions.V1dot0) {
+        const v1 = {
+            version: "1.0",
+            conf: convertDtoProductConfToV1(conf, true),
+        };
+        result.push(v1);
+    }
+    if ((sendVersions & CfgProdConfMessageVersions.V2dot0) ===
+        CfgProdConfMessageVersions.V2dot0) {
+        const v2 = {
+            version: "2.0",
+            conf,
+        };
+        result.push(v2);
+    }
+    return { subMessages: result, initial };
+};
+CfgIOProdConfConnector.makeMessageListener = (callback) => (message) => __awaiter(void 0, void 0, void 0, function* () {
+    const prodConfMessage = message;
+    yield callback(prodConfMessage);
+});
+CfgIOProdConfConnector.makeProdConfListener = (callback, includeInSend) => (n) => {
+    if (!n.committed) {
+        return;
+    }
+    callback(n.freshRef.getDtoConf(includeInSend));
+};

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,16 @@
-import { DtoProductConfiguration } from "../CatalogueAPI.js";
+import { DtoProductConf } from "../CatalogueAPI.js";
+import { CfgProdConfParts } from "../utilitiesConfiguration.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, includeInSend?: CfgProdConfParts);
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgProdConfMessage;
 }
 //# sourceMappingURL=CfgObservableStateToProdConfConnector.d.ts.map

package/dist/io/CfgObservableStateToProdConfConnector.js

@@ -1,14 +1,14 @@
+import { CfgProdConfParts } from "../utilitiesConfiguration.js";
 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, includeInSend = CfgProdConfParts.NoExtra) {
+        super(manager, includeInSend);
         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);
         }