@configura/web-api 2.0.0-alpha.0 → 2.0.0-alpha.11

package/dist/io/CfgHistoryToProdConfConnector.d.ts

@@ -1,21 +1,21 @@
-import { DtoConfProd } from "../CatalogueAPI.js";
-import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
-import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
-export declare function dtoConfToString(conf: DtoConfProd): string;
-export declare function stringToDtoConf(conf: string): DtoConfProd;
-/**
- * Instantiating this will make the browser history (and URL) update with the product configuration.
- */
-export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector<CfgHistoryManagerSendData<CfgProdConfMessage>> {
-    private readonly _useHistoryPush;
-    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 _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>;
-}
+import { DtoProductConfiguration } from "../CatalogueAPI.js";
+import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
+export declare const dtoConfToCompactString: (conf: DtoProductConfiguration) => string;
+export declare const compactStringToDtoConf: (versionAndConf: 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 _qsKey;
+    /**
+     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     * @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>;
+}
 //# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -1,56 +1,101 @@
-import { CfgHistoryManager } from "./CfgHistoryManager.js";
-import { CfgIOProdConfConnector, CfgProdConfMessageVersions, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
-const jsonKeyRegex = /"([^"]+)":/g;
-const keyMap = [
-    ["configuration", "cn"],
-    ["additionalProducts", "as"],
-    ["prodParams", "pp"],
-    ["refKey", "rk"],
-    ["selected", "se"],
-    ["features", "fs"],
-    ["code", "cd"],
-    ["options", "os"],
-    ["numericValue", "nu"],
-    ["groupCode", "gc"],
-    ["unit", "un"],
-];
-// todo: Could be worth making faster
-const toCompact = (key) => { var _a, _b; return (_b = (_a = keyMap.find((i) => i[0] === key)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : key; };
-const toExpanded = (key) => { var _a, _b; return (_b = (_a = keyMap.find((i) => i[1] === key)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : key; };
-export function dtoConfToString(conf) {
-    const stringified = JSON.stringify(conf, undefined, "");
-    return stringified.replace(jsonKeyRegex, (_, key) => `"${toCompact(key)}":`);
-}
-export function stringToDtoConf(conf) {
-    const expandedKeys = conf.replace(jsonKeyRegex, (_, key) => `"${toExpanded(key)}":`);
-    return JSON.parse(expandedKeys);
-}
-/**
- * Instantiating this will make the browser history (and URL) update with the product configuration.
- */
-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 _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;
-        this._qsKey = _qsKey;
-    }
-    getInitialProdConf() {
-        const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
-        if (s === undefined) {
-            return undefined;
-        }
-        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,
-        };
-    }
-}
+import { CfgHistoryManager } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
+const versionedRegex = /^v(\d+)(.+)$/;
+const jsonKeyRegex = /"([^"]+)":/g;
+const swapIntoUrlAdaptedRegex = /[{}"]/g;
+const swapFromUrlAdaptedRegex = /[-~_]/g;
+const shortToLong = new Map();
+const longToShort = new Map();
+// The replacement scheme here assumes this will only be used for keys
+// in DtoProductConfiguration and the knowledge that it contains no one
+// one char keys.
+for (const [long, short] of [
+    ["configuration", "c"],
+    ["additionalProducts", "a"],
+    ["prodParams", "p"],
+    ["refKey", "r"],
+    ["selected", "s"],
+    ["features", "f"],
+    ["code", "d"],
+    ["options", "o"],
+    ["numericValue", "n"],
+    ["groupCode", "g"],
+    ["unit", "u"],
+]) {
+    shortToLong.set(short, long);
+    longToShort.set(long, short);
+}
+/**
+ * As certain chars are abundant in JSON but less abundant in the actual data
+ * we swap these so that frequent characters do not need to be URL-encoded.
+ */
+const jsonStringSwapCharsForUrl = (data) => data.replace(swapIntoUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "{":
+            return "~";
+        case "}":
+            return "-";
+        case '"':
+            return "_";
+        default:
+            throw new Error(`Unexpected char "${char}" in swap for URL`);
+    }
+});
+const jsonStringSwapCharsFromUrl = (data) => data.replace(swapFromUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "~":
+            return "{";
+        case "-":
+            return "}";
+        case "_":
+            return '"';
+        default:
+            throw new Error(`Unexpected char "${char}" in swap from URL`);
+    }
+});
+const compactDtoConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = longToShort.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+const expandDtoConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = shortToLong.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+export const dtoConfToCompactString = (conf) => "v1" + jsonStringSwapCharsForUrl(compactDtoConfJsonKeys(JSON.stringify(conf, undefined, "")));
+export const compactStringToDtoConf = (versionAndConf) => {
+    const match = versionedRegex.exec(versionAndConf);
+    if (match === null) {
+        throw new Error("Could not match version string");
+    }
+    const [, version, conf] = match;
+    if (version !== "1") {
+        throw new Error("Unknown packed URL version");
+    }
+    if (conf === "") {
+        throw new Error("No conf found");
+    }
+    return JSON.parse(expandDtoConfJsonKeys(jsonStringSwapCharsFromUrl(conf)));
+};
+/**
+ * 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 _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;
+        this._qsKey = _qsKey;
+    }
+    getInitialProdConf() {
+        const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
+        if (s === undefined) {
+            return undefined;
+        }
+        return compactStringToDtoConf(s);
+    }
+    makeSendData(conf, initial) {
+        return {
+            message: CfgIOProdConfConnector.makeMessage(conf, initial, CfgProdConfMessageVersions.V2dot0),
+            qsKeyValues: new Map([[STAGE_PROD_CONF_MESSAGE_KEY, dtoConfToCompactString(conf)]]),
+            useHistoryPush: this._useHistoryPush,
+        };
+    }
+}

package/dist/io/CfgIOManager.d.ts

@@ -1,49 +1,49 @@
-declare type ConfiguraAttribute = "C0nf1gura";
-declare type ConfiguraShebang = "arug1fn0C";
-declare const CONFIGURA_ATTRIBUTE: ConfiguraAttribute;
-export declare type IOManagerListener = (data: unknown) => Promise<void>;
-/**
- * The container format used when the environment is globally shared with things
- * outside our control. The "shebang" is a magic string that should prevent from a
- * CfgIOContainer being confused with something else.
- */
-export declare type CfgIOContainer = {
-    [CONFIGURA_ATTRIBUTE]: ConfiguraShebang;
-    messages: {
-        [index: string]: unknown;
-    };
-};
-/**
- * Base class for classes handling input and output in globally shared environments.
- */
-export declare abstract class CfgIOManager<S> {
-    /**
-     * Listen for the message messageKey being received.
-     */
-    listenForMessage(l: IOManagerListener, messageKey: string): boolean;
-    /**
-     * Removes the listener
-     */
-    stopListenForMessage(l: IOManagerListener): boolean;
-    static isIOContainer: (data: unknown) => data is CfgIOContainer;
-    static hasIOContainerMessageKey: (container: CfgIOContainer, messageKey: string) => boolean;
-    static getMessageFromIOContainer: (container: unknown, messageKey: string) => unknown;
-    static makeContainer: (messages: {
-        [index: string]: unknown;
-    }) => CfgIOContainer;
-    private _receiveInProgress;
-    private static _inhibitAllReceive;
-    get receiveInProgress(): boolean;
-    private _messageListeners;
-    private _getIndexOfMessageListener;
-    get hasMessageListeners(): boolean;
-    protected _containerListener(data: unknown): void;
-    /**
-     * Send the data with messageKey. This can for example be pushing or
-     * replacing on the history stack or sending a message using the
-     * window.message API.
-     */
-    abstract send(messageKey: string, data: S): void;
-}
-export {};
+declare type ConfiguraAttribute = "C0nf1gura";
+declare type ConfiguraShebang = "arug1fn0C";
+declare const CONFIGURA_ATTRIBUTE: ConfiguraAttribute;
+export declare type IOManagerListener = (data: unknown) => Promise<void>;
+/**
+ * The container format used when the environment is globally shared with things
+ * outside our control. The "shebang" is a magic string that should prevent from a
+ * CfgIOContainer being confused with something else.
+ */
+export declare type CfgIOContainer = {
+    [CONFIGURA_ATTRIBUTE]: ConfiguraShebang;
+    messages: {
+        [index: string]: unknown;
+    };
+};
+/**
+ * Base class for classes handling input and output in globally shared environments.
+ */
+export declare abstract class CfgIOManager<S> {
+    /**
+     * Listen for the message messageKey being received.
+     */
+    listenForMessage(l: IOManagerListener, messageKey: string): boolean;
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l: IOManagerListener): boolean;
+    static isIOContainer: (data: unknown) => data is CfgIOContainer;
+    static hasIOContainerMessageKey: (container: CfgIOContainer, messageKey: string) => boolean;
+    static getMessageFromIOContainer: (container: unknown, messageKey: string) => unknown;
+    static makeContainer: (messages: {
+        [index: string]: unknown;
+    }) => CfgIOContainer;
+    private _receiveInProgress;
+    private static _inhibitAllReceive;
+    get receiveInProgress(): boolean;
+    private _messageListeners;
+    private _getIndexOfMessageListener;
+    get hasMessageListeners(): boolean;
+    protected _containerListener(data: unknown): void;
+    /**
+     * Send the data with messageKey. This can for example be pushing or
+     * replacing on the history stack or sending a message using the
+     * window.message API.
+     */
+    abstract send(messageKey: string, data: S): void;
+}
+export {};
 //# sourceMappingURL=CfgIOManager.d.ts.map

package/dist/io/CfgIOManager.js

@@ -1,115 +1,115 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const CONFIGURA_ATTRIBUTE = "C0nf1gura";
-const CONFIGURA_SHEBANG = "arug1fn0C";
-// Support function. Did not manage to check both attribute and value in one step
-const hasConfiguraAttribute = (data) => {
-    return typeof data === "object" && data !== null;
-};
-/**
- * Base class for classes handling input and output in globally shared environments.
- */
-export class CfgIOManager {
-    constructor() {
-        // 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);
-    }
-    /**
-     * Listen for the message messageKey being received.
-     */
-    listenForMessage(l, messageKey) {
-        if (this._getIndexOfMessageListener(l) !== -1) {
-            console.warn("Tried to add listener twice");
-            return false;
-        }
-        this._messageListeners.push({ l, messageKey });
-        return true;
-    }
-    /**
-     * Removes the listener
-     */
-    stopListenForMessage(l) {
-        const i = this._getIndexOfMessageListener(l);
-        if (i === -1) {
-            console.warn("Tried to stopListen on unknown listener");
-            return false;
-        }
-        this._messageListeners.splice(i, 1);
-        return true;
-    }
-    get receiveInProgress() {
-        return this._receiveInProgress;
-    }
-    get hasMessageListeners() {
-        return 0 < this._messageListeners.length;
-    }
-    _containerListener(data) {
-        if (CfgIOManager._inhibitAllReceive) {
-            return;
-        }
-        if (!CfgIOManager.isIOContainer(data)) {
-            return;
-        }
-        CfgIOManager._inhibitAllReceive = true;
-        this._receiveInProgress = true;
-        // The 15 or so rows below is one of the cases where I believe building a clever
-        // data structure of so would probably be worse for performance than just looping
-        // as the subscribers are expected to be very few
-        const listeners = this._messageListeners;
-        const allMessageKeys = listeners.reduce((a, c) => {
-            a.add(c.messageKey);
-            return a;
-        }, new Set());
-        const promises = [];
-        (() => __awaiter(this, void 0, void 0, function* () {
-            for (const messageKey of allMessageKeys) {
-                if (!CfgIOManager.hasIOContainerMessageKey(data, messageKey)) {
-                    continue;
-                }
-                const message = CfgIOManager.getMessageFromIOContainer(data, messageKey);
-                for (const item of listeners) {
-                    if (item.messageKey !== messageKey) {
-                        continue;
-                    }
-                    // async, not waiting. Might need to change.
-                    promises.push(item.l(message));
-                }
-            }
-        }))();
-        Promise.all(promises)
-            .then(() => {
-            this._receiveInProgress = false;
-            CfgIOManager._inhibitAllReceive = false;
-        })
-            .catch(() => {
-            this._receiveInProgress = false;
-            CfgIOManager._inhibitAllReceive = false;
-        });
-    }
-}
-CfgIOManager.isIOContainer = (data) => hasConfiguraAttribute(data) && data[CONFIGURA_ATTRIBUTE] === CONFIGURA_SHEBANG;
-CfgIOManager.hasIOContainerMessageKey = (container, messageKey) => messageKey in container.messages;
-CfgIOManager.getMessageFromIOContainer = (container, messageKey) => {
-    if (!CfgIOManager.isIOContainer(container)) {
-        throw new Error("The passed data was not a CfgIOContainer. It is to be expected that such data messages can arrive, so please use isIOContainer function to filter them out before calling this.");
-    }
-    if (!CfgIOManager.hasIOContainerMessageKey(container, messageKey)) {
-        throw new Error(`The passed data did not have the messageKey "${messageKey}". You can test for this using hasIOContainerMessageKey function.`);
-    }
-    return container.messages[messageKey];
-};
-CfgIOManager.makeContainer = (messages) => ({
-    [CONFIGURA_ATTRIBUTE]: CONFIGURA_SHEBANG,
-    messages,
-});
-CfgIOManager._inhibitAllReceive = false;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const CONFIGURA_ATTRIBUTE = "C0nf1gura";
+const CONFIGURA_SHEBANG = "arug1fn0C";
+// Support function. Did not manage to check both attribute and value in one step
+const hasConfiguraAttribute = (data) => {
+    return typeof data === "object" && data !== null;
+};
+/**
+ * Base class for classes handling input and output in globally shared environments.
+ */
+export class CfgIOManager {
+    constructor() {
+        // 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);
+    }
+    /**
+     * Listen for the message messageKey being received.
+     */
+    listenForMessage(l, messageKey) {
+        if (this._getIndexOfMessageListener(l) !== -1) {
+            console.warn("Tried to add listener twice");
+            return false;
+        }
+        this._messageListeners.push({ l, messageKey });
+        return true;
+    }
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l) {
+        const i = this._getIndexOfMessageListener(l);
+        if (i === -1) {
+            console.warn("Tried to stopListen on unknown listener");
+            return false;
+        }
+        this._messageListeners.splice(i, 1);
+        return true;
+    }
+    get receiveInProgress() {
+        return this._receiveInProgress;
+    }
+    get hasMessageListeners() {
+        return 0 < this._messageListeners.length;
+    }
+    _containerListener(data) {
+        if (CfgIOManager._inhibitAllReceive) {
+            return;
+        }
+        if (!CfgIOManager.isIOContainer(data)) {
+            return;
+        }
+        CfgIOManager._inhibitAllReceive = true;
+        this._receiveInProgress = true;
+        // The 15 or so rows below is one of the cases where I believe building a clever
+        // data structure of so would probably be worse for performance than just looping
+        // as the subscribers are expected to be very few
+        const listeners = this._messageListeners;
+        const allMessageKeys = listeners.reduce((a, c) => {
+            a.add(c.messageKey);
+            return a;
+        }, new Set());
+        const promises = [];
+        (() => __awaiter(this, void 0, void 0, function* () {
+            for (const messageKey of allMessageKeys) {
+                if (!CfgIOManager.hasIOContainerMessageKey(data, messageKey)) {
+                    continue;
+                }
+                const message = CfgIOManager.getMessageFromIOContainer(data, messageKey);
+                for (const item of listeners) {
+                    if (item.messageKey !== messageKey) {
+                        continue;
+                    }
+                    // async, not waiting. Might need to change.
+                    promises.push(item.l(message));
+                }
+            }
+        }))();
+        Promise.all(promises)
+            .then(() => {
+            this._receiveInProgress = false;
+            CfgIOManager._inhibitAllReceive = false;
+        })
+            .catch(() => {
+            this._receiveInProgress = false;
+            CfgIOManager._inhibitAllReceive = false;
+        });
+    }
+}
+CfgIOManager.isIOContainer = (data) => hasConfiguraAttribute(data) && data[CONFIGURA_ATTRIBUTE] === CONFIGURA_SHEBANG;
+CfgIOManager.hasIOContainerMessageKey = (container, messageKey) => messageKey in container.messages;
+CfgIOManager.getMessageFromIOContainer = (container, messageKey) => {
+    if (!CfgIOManager.isIOContainer(container)) {
+        throw new Error("The passed data was not a CfgIOContainer. It is to be expected that such data messages can arrive, so please use isIOContainer function to filter them out before calling this.");
+    }
+    if (!CfgIOManager.hasIOContainerMessageKey(container, messageKey)) {
+        throw new Error(`The passed data did not have the messageKey "${messageKey}". You can test for this using hasIOContainerMessageKey function.`);
+    }
+    return container.messages[messageKey];
+};
+CfgIOManager.makeContainer = (messages) => ({
+    [CONFIGURA_ATTRIBUTE]: CONFIGURA_SHEBANG,
+    messages,
+});
+CfgIOManager._inhibitAllReceive = false;

package/dist/io/CfgIOProdConfConnector.d.ts

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