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

package/dist/io/CfgWindowEventManager.js

@@ -1,38 +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);
-    }
-}
+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

@@ -1,41 +1,41 @@
-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
- */
-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;
-}
+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

@@ -1,84 +1,91 @@
-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
- */
-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) {
-        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;
-    }
-}
+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,
+        });
+        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);
+        }
+    }
+    _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

@@ -1,17 +1,17 @@
-import { DtoConfProd } 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> {
-    constructor(manager: CfgWindowMessageManager, doValidate?: boolean, sendVersions?: CfgProdConfMessageVersions, includeExtendedDataInSend?: boolean, includeProdParamsInSend?: boolean);
-    protected makeSendData(conf: DtoConfProd, initial: boolean): CfgProdConfMessage;
-}
+import { DtoProductConf } from "../CatalogueAPI.js";
+import { CfgIOProdConfConnector, CfgProdConfMessage, CfgProdConfMessageVersions, CfgProdConfParts } 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 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, _sendVersions?: CfgProdConfMessageVersions, includeInSend?: CfgProdConfParts);
+    protected makeSendData(conf: DtoProductConf, initial: boolean): CfgProdConfMessage;
+}
 //# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -1,18 +1,18 @@
-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, sendVersions, includeExtendedDataInSend, includeProdParamsInSend);
-    }
-    makeSendData(conf, initial) {
-        return this.makeMessage(conf, initial);
-    }
-}
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, CfgProdConfParts, } 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 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, _sendVersions = CfgProdConfMessageVersions.V2dot0, includeInSend = CfgProdConfParts.NoExtra) {
+        super(manager, includeInSend);
+        this._sendVersions = _sendVersions;
+    }
+    makeSendData(conf, initial) {
+        return CfgIOProdConfConnector.makeMessage(conf, initial, this._sendVersions);
+    }
+}

package/dist/io/index.d.ts

@@ -1,9 +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";
+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

@@ -1,8 +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";
+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