@configura/web-api 1.6.2 → 2.0.0-alpha.10

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -0,0 +1,56 @@
+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

package/dist/io/CfgIOProdConfConnector.js

@@ -0,0 +1,143 @@
+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());
+    });
+};
+import { convertDtoConfProdToV1 } 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";
+    CfgProdConfMessageVersions[CfgProdConfMessageVersions["V2dot0"] = 2] = "V2dot0";
+})(CfgProdConfMessageVersions || (CfgProdConfMessageVersions = {}));
+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
+    ) {
+        this._ioManager = _ioManager;
+        this._doValidate = _doValidate;
+        this._includeExtendedDataInSend = _includeExtendedDataInSend;
+        this._includeProdParamsInSend = _includeProdParamsInSend;
+        this._stopListenToMessage = undefined;
+        this._stopListenToProdConf = undefined;
+        this.destroy = () => {
+            var _a, _b;
+            (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
+        };
+        this.setProduct = (product) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const currentProduct = this._product;
+            const newProduct = product;
+            this._product = newProduct;
+            // If same product don't do anything at all
+            if (currentProduct !== undefined &&
+                newProduct !== undefined &&
+                currentProduct.isBackedBySame(newProduct)) {
+                return;
+            }
+            if (currentProduct !== undefined) {
+                (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
+                (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
+            }
+            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._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 = getHighestVersionProdConfMessage(subMessages);
+                if (isCfgProdConfMessageV1(highestVersionMessage)) {
+                    yield newProduct.setApiSelection(highestVersionMessage.conf, this._doValidate);
+                    return;
+                }
+                if (isCfgProdConfMessageV2(highestVersionMessage)) {
+                    yield newProduct.setDtoConf(highestVersionMessage.conf, this._doValidate);
+                    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._send = (data) => this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, data);
+    }
+    getInitialProdConf() {
+        return undefined;
+    }
+    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);
+        }
+        return { subMessages: result, initial };
+    }
+    static makeMessageListener(callback) {
+        return (message) => __awaiter(this, void 0, void 0, function* () {
+            const prodConfMessage = message;
+            yield callback(prodConfMessage);
+        });
+    }
+    /**
+     * Register the callback to listen for Product Configuration messages
+     * @returns A function which when called will cancel listening
+     */
+    static listenForMessage(callback, ioManager) {
+        const listener = this.makeMessageListener(callback);
+        ioManager.listenForMessage(listener, STAGE_PROD_CONF_MESSAGE_KEY);
+        return () => {
+            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);
+        product.listenForChange(listener);
+        return () => {
+            product.stopListenForChange(listener);
+        };
+    }
+}

package/dist/io/CfgObservableStateManager.d.ts

@@ -0,0 +1,26 @@
+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;
+    private constructor();
+    readonly stateObservable: Observable<string>;
+    private messagesState;
+    get stateAsString(): string;
+    set stateAsString(s: string);
+    listenForStateChange(listener: (v: string) => void): void;
+    stopListenForStateChange(listener: (v: string) => void): void;
+    listenForMessage(l: IOManagerListener, messageKey: string): boolean;
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l: IOManagerListener): boolean;
+    private _stateListenerBound;
+    private _stateListener;
+    send(messageKey: string, data: unknown): void;
+}
+//# sourceMappingURL=CfgObservableStateManager.d.ts.map

package/dist/io/CfgObservableStateManager.js

@@ -0,0 +1,69 @@
+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();
+        this.stateObservable = new Observable();
+        this.messagesState = {};
+        this._stateListenerBound = this._stateListener.bind(this);
+    }
+    static get instance() {
+        if (this._instance === undefined) {
+            this._instance = new CfgObservableStateManager();
+        }
+        return this._instance;
+    }
+    get stateAsString() {
+        return JSON.stringify(CfgObservableStateManager.makeContainer(this.messagesState), null, 2);
+    }
+    set stateAsString(s) {
+        this.stateObservable.notifyAll(s);
+    }
+    listenForStateChange(listener) {
+        this.stateObservable.listen(listener);
+    }
+    stopListenForStateChange(listener) {
+        this.stateObservable.stopListen(listener);
+    }
+    listenForMessage(l, messageKey) {
+        const hadListeners = this.hasMessageListeners;
+        const didStartListen = super.listenForMessage(l, messageKey);
+        if (!hadListeners && didStartListen) {
+            this.stateObservable.listen(this._stateListenerBound, this);
+        }
+        return didStartListen;
+    }
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l) {
+        const didStopListen = super.stopListenForMessage(l);
+        if (didStopListen && !this.hasMessageListeners) {
+            this.stateObservable.stopListen(this._stateListenerBound);
+        }
+        return didStopListen;
+    }
+    _stateListener(data) {
+        let asJson;
+        try {
+            asJson = JSON.parse(data);
+        }
+        catch (_a) {
+            throw new Error("Not JSON data");
+        }
+        if (!CfgIOManager.isIOContainer(asJson)) {
+            console.warn("Not a readable IO container");
+            return;
+        }
+        this.messagesState = asJson.messages;
+        super._containerListener(asJson);
+    }
+    send(messageKey, data) {
+        this.messagesState[messageKey] = data;
+        this.stateObservable.notifyAll(this.stateAsString, this);
+    }
+}

package/dist/io/CfgObservableStateToProdConfConnector.d.ts

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

package/dist/io/CfgObservableStateToProdConfConnector.js

@@ -0,0 +1,17 @@
+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);
+        this._sendVersions = _sendVersions;
+    }
+    makeSendData(conf, initial) {
+        return CfgIOProdConfConnector.makeMessage(conf, initial, this._sendVersions);
+    }
+}

package/dist/io/CfgWindowEventManager.d.ts

@@ -0,0 +1,22 @@
+import { CfgIOManager, IOManagerListener } from "./CfgIOManager.js";
+/**
+ * Base class for classes handling input and output in globally shared environments, using
+ * event listeners on the window object, for example the History API and window.message API.
+ * These are global resources where data not being handled by Stage can appear.
+ */
+export declare abstract class CfgWindowEventManager<K extends keyof WindowEventMap, S> extends CfgIOManager<S> {
+    /**
+     * Listen for the message messageKey being received. This can for example be the history stack
+     * being popped or a window.message being received.
+     */
+    listenForMessage(l: IOManagerListener, messageKey: string): boolean;
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l: IOManagerListener): boolean;
+    private _windowEventListenerBound;
+    private _windowEventListener;
+    protected abstract readonly eventType: K;
+    protected abstract getDataFromEvent(event: WindowEventMap[K]): unknown;
+}
+//# sourceMappingURL=CfgWindowEventManager.d.ts.map

package/dist/io/CfgWindowEventManager.js

@@ -0,0 +1,38 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+/**
+ * Base class for classes handling input and output in globally shared environments, using
+ * event listeners on the window object, for example the History API and window.message API.
+ * These are global resources where data not being handled by Stage can appear.
+ */
+export class CfgWindowEventManager extends CfgIOManager {
+    constructor() {
+        super(...arguments);
+        this._windowEventListenerBound = this._windowEventListener.bind(this);
+    }
+    /**
+     * Listen for the message messageKey being received. This can for example be the history stack
+     * being popped or a window.message being received.
+     */
+    listenForMessage(l, messageKey) {
+        const hadListeners = this.hasMessageListeners;
+        const didStartListen = super.listenForMessage(l, messageKey);
+        if (!hadListeners && didStartListen) {
+            window.addEventListener(this.eventType, this._windowEventListenerBound);
+        }
+        return didStartListen;
+    }
+    /**
+     * Removes the listener
+     */
+    stopListenForMessage(l) {
+        const didStopListen = super.stopListenForMessage(l);
+        if (didStopListen && !this.hasMessageListeners) {
+            window.removeEventListener(this.eventType, this._windowEventListenerBound);
+        }
+        return didStopListen;
+    }
+    _windowEventListener(event) {
+        const data = this.getDataFromEvent(event);
+        super._containerListener(data);
+    }
+}

package/dist/io/CfgWindowMessageManager.d.ts

@@ -0,0 +1,41 @@
+import { IOManagerListener } from "./CfgIOManager.js";
+import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
+/**
+ * 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;
+    static get instance(): CfgWindowMessageManager;
+    /**
+     * If uncertain about security, please read https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+     */
+    private constructor();
+    private _doListenForIncoming;
+    private _remoteEnds;
+    private _targetOrigin;
+    private _acceptableMessageOrigin;
+    /**
+     * Listen for incoming messages or not
+     */
+    set doListenForIncoming(v: boolean);
+    /**
+     * What window object outgoing messages should be sent to. Leave empty if you don't want to broadcast.
+     */
+    set remoteEnds(v: Window[]);
+    /**
+     * What origins of the target window are acceptable.
+     */
+    set targetOrigin(v: string);
+    /**
+     * @param _acceptableMessageOrigin What message origins we accept incoming from.
+     */
+    set acceptableMessageOrigin(v: string);
+    listenForMessage(l: IOManagerListener, messageKey: string): boolean;
+    stopListenForMessage(l: IOManagerListener): boolean;
+    send(messageKey: string, data: unknown): void;
+    protected _containerListener(event: MessageEvent): void;
+    protected readonly eventType = "message";
+    protected getDataFromEvent(event: MessageEvent): unknown;
+}
+//# sourceMappingURL=CfgWindowMessageManager.d.ts.map

package/dist/io/CfgWindowMessageManager.js

@@ -0,0 +1,87 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
+/**
+ * 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 {
+    /**
+     * If uncertain about security, please read https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+     */
+    constructor() {
+        super();
+        this._doListenForIncoming = true;
+        this._remoteEnds = [];
+        this._targetOrigin = "*";
+        this._acceptableMessageOrigin = undefined;
+        this.eventType = "message";
+    }
+    static get instance() {
+        if (this._instance === undefined) {
+            this._instance = new CfgWindowMessageManager();
+        }
+        return this._instance;
+    }
+    /**
+     * Listen for incoming messages or not
+     */
+    set doListenForIncoming(v) {
+        this._doListenForIncoming = v;
+    }
+    /**
+     * What window object outgoing messages should be sent to. Leave empty if you don't want to broadcast.
+     */
+    set remoteEnds(v) {
+        for (const remote of v) {
+            if (remote === window) {
+                console.warn("You are providing your own window as a remote end.");
+            }
+        }
+        this._remoteEnds = v;
+    }
+    /**
+     * What origins of the target window are acceptable.
+     */
+    set targetOrigin(v) {
+        this._targetOrigin = v;
+    }
+    /**
+     * @param _acceptableMessageOrigin What message origins we accept incoming from.
+     */
+    set acceptableMessageOrigin(v) {
+        this._acceptableMessageOrigin = v;
+    }
+    listenForMessage(l, messageKey) {
+        if (!this._doListenForIncoming) {
+            return false;
+        }
+        return super.listenForMessage(l, messageKey);
+    }
+    stopListenForMessage(l) {
+        if (!this._doListenForIncoming) {
+            return false;
+        }
+        return super.stopListenForMessage(l);
+    }
+    send(messageKey, data) {
+        if (this.receiveInProgress) {
+            return;
+        }
+        const container = CfgIOManager.makeContainer({
+            [messageKey]: data,
+        });
+        for (const remoteEnd of this._remoteEnds) {
+            remoteEnd.postMessage(container, this._targetOrigin);
+        }
+    }
+    _containerListener(event) {
+        if (this._acceptableMessageOrigin !== undefined &&
+            event.origin !== this._acceptableMessageOrigin) {
+            return;
+        }
+        super._containerListener(event);
+    }
+    getDataFromEvent(event) {
+        return event.data;
+    }
+}

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

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

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -0,0 +1,19 @@
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProdConfConnector.js";
+/**
+ * Instantiating this will make Stage send product configuration changes using the post message-API.
+ * It will also make Stage listen for incoming product configuration update messages.
+ * This can be used to communicate in and out of an iframe for example.
+ * @param doValidate Run server side product validation for incoming
+ * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
+ * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
+ * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
+ */
+export class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, doValidate = true, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, doValidate, includeExtendedDataInSend, includeProdParamsInSend);
+        this._sendVersions = _sendVersions;
+    }
+    makeSendData(conf, initial) {
+        return CfgIOProdConfConnector.makeMessage(conf, initial, this._sendVersions);
+    }
+}

package/dist/io/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./CfgHistoryManager.js";
+export * from "./CfgHistoryToProdConfConnector.js";
+export * from "./CfgIOManager.js";
+export * from "./CfgIOProdConfConnector.js";
+export * from "./CfgObservableStateManager.js";
+export * from "./CfgObservableStateToProdConfConnector.js";
+export * from "./CfgWindowMessageManager.js";
+export * from "./CfgWindowMessageToProdConfConnector.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/io/index.js

@@ -0,0 +1,8 @@
+export * from "./CfgHistoryManager.js";
+export * from "./CfgHistoryToProdConfConnector.js";
+export * from "./CfgIOManager.js";
+export * from "./CfgIOProdConfConnector.js";
+export * from "./CfgObservableStateManager.js";
+export * from "./CfgObservableStateToProdConfConnector.js";
+export * from "./CfgWindowMessageManager.js";
+export * from "./CfgWindowMessageToProdConfConnector.js";

package/dist/material/CfgMaterialMapping.d.ts

@@ -1,8 +1,8 @@
-import { CfgProductConfiguration } from "../productConfiguration/CfgProductConfiguration.js";
-import { CfgMtrlApplication } from "./CfgMtrlApplication.js";
-import { CfgMtrlSourceWithMetaData } from "./CfgMtrlSourceWithMetaData.js";
-export declare type CfgMaterialMapping = Map<string, CfgMtrlSourceWithMetaData>;
-export declare function aggregateAllMaterialApplications(applicationAreas: CfgMtrlApplication[], productMtrlApplications: CfgMtrlApplication[], productConfiguration: CfgProductConfiguration, debugMtrlApplications?: CfgMtrlApplication[]): CfgMaterialMapping;
-export declare function logMtrlSourceWithMetaDataToConsole(mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData): void;
-export declare function logMaterialMappingToConsole(areasToMaterials: CfgMaterialMapping): void;
+import { CfgProductConfiguration } from "../productConfiguration/CfgProductConfiguration.js";
+import { CfgMtrlApplication } from "./CfgMtrlApplication.js";
+import { CfgMtrlSourceWithMetaData } from "./CfgMtrlSourceWithMetaData.js";
+export declare type CfgMaterialMapping = Map<string, CfgMtrlSourceWithMetaData>;
+export declare function aggregateAllMaterialApplications(applicationAreas: CfgMtrlApplication[], productMtrlApplications: CfgMtrlApplication[], productConfiguration: CfgProductConfiguration, debugMtrlApplications?: CfgMtrlApplication[]): CfgMaterialMapping;
+export declare function logMtrlSourceWithMetaDataToConsole(mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData): void;
+export declare function logMaterialMappingToConsole(areasToMaterials: CfgMaterialMapping): void;
 //# sourceMappingURL=CfgMaterialMapping.d.ts.map