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

package/dist/io/CfgObservableStateManager.d.ts

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

package/dist/io/CfgObservableStateToProdConfConnector.js

@@ -0,0 +1,16 @@
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, } from "./CfgIOProdConfConnector.js";
+/**
+ * Instantiating this will make the observable state update with the product configuration.
+ * @param doValidate Run server side product validation for incoming
+ * @param sendVersions What versions of the productConfiguration shall be sent? Multiple can be selected
+ * @param includeExtendedDataInSend Only for version 2.0. Includes unit and groupCode.
+ * @param includeProdParamsInSend Only for version 2.0. Includes product params, in both main and additional products.
+ */
+export class CfgObservableStateToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, doValidate = true, sendVersions = CfgProdConfMessageVersions.V2dot0, includeExtendedDataInSend = false, includeProdParamsInSend = false) {
+        super(manager, doValidate, sendVersions, includeExtendedDataInSend, includeProdParamsInSend);
+    }
+    makeSendData(conf, initial) {
+        return this.makeMessage(conf, initial);
+    }
+}

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 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<unknown>): void;
+    protected readonly eventType = "message";
+    protected getDataFromEvent(event: MessageEvent<unknown>): unknown;
+}
+//# sourceMappingURL=CfgWindowMessageManager.d.ts.map

package/dist/io/CfgWindowMessageManager.js

@@ -0,0 +1,84 @@
+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;
+    }
+}

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

@@ -0,0 +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;
+}
+//# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

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

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/CfgMtrlApplication.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationArea, MtrlApplication } from "../CatalogueAPI.js";
+import { DtoApplicationArea, DtoMtrlApplication } from "../CatalogueAPI.js";
 import { CfgMtrlApplicationSource } from "./CfgMtrlApplicationSource.js";
 import { CfgMtrlSource } from "./CfgMtrlSource.js";
 export declare class CfgMtrlApplication {
@@ -9,7 +9,7 @@ export declare class CfgMtrlApplication {
     static fromUrlForDebug(areaTags: string[], url: string): CfgMtrlApplication;
     static fromBufferForDebug(areaTags: string[], fileName: string, buffer: ArrayBuffer): CfgMtrlApplication;
     private static fromMtrlSourceForDebug;
-    static fromMtrlLikeApplication(source: CfgMtrlApplicationSource, application: ApplicationArea | MtrlApplication): CfgMtrlApplication;
+    static fromMtrlLikeApplication(source: CfgMtrlApplicationSource, application: DtoApplicationArea | DtoMtrlApplication): CfgMtrlApplication;
     private constructor();
     get source(): CfgMtrlApplicationSource;
     get areaTags(): string[] | undefined;

package/dist/productConfiguration/CfgFeature.d.ts

@@ -1,5 +1,5 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { Feature, SelectedOption, SyncGroup, SyncGroupMethods } from "../CatalogueAPI.js";
+import { DtoConfFeature, DtoFeature, DtoSelectedOption, DtoSyncGroup, DtoSyncGroupMethods } from "../CatalogueAPI.js";
 import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { SyncCode } from "../syncGroups/SyncGroupsHandler.js";
@@ -22,6 +22,7 @@ export declare enum SelectionType {
 }
 export declare type FeatureChangeNotification = {
     freshRef: CfgFeature;
+    committed: boolean;
 };
 /**
  * This class is meant to only be used through CfgFeature. It should
@@ -30,14 +31,14 @@ export declare type FeatureChangeNotification = {
  * should be used and interacted with.
  */
 export declare class _CfgFeatureInternal {
-    readonly rawFeature: Feature;
+    readonly rawFeature: DtoFeature;
     private readonly allRawFeatures;
     readonly key: string;
     readonly parent: _CfgProductConfigurationInternal | _CfgOptionInternal;
     readonly parentConfiguration: _CfgProductConfigurationInternal;
     readonly parentProduct: _CfgProductInternal;
     readonly rootProduct: _CfgProductInternal;
-    constructor(rawFeature: Feature, allRawFeatures: Feature[], key: string, // Unique amongst siblings
+    constructor(rawFeature: DtoFeature, allRawFeatures: DtoFeature[], key: string, // Unique amongst siblings
     parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal);
     readonly selectionType: SelectionType;
     private _options;
@@ -51,16 +52,16 @@ export declare class _CfgFeatureInternal {
     get numericValue(): number | undefined;
     setNumericValue: (val: number) => Promise<boolean>;
     get description(): string;
-    get syncGroup(): SyncGroup | undefined;
+    get syncGroup(): DtoSyncGroup | undefined;
     /**
      * @return one of the following, in order:
      * - undefined if the Feature lacks a syncGroup.
      * - false if the syncGroup doesn't fulfill the optional mustSupport requirement.
      * - syncCode from the syncGroup.
      */
-    getSyncCode(mustSupport?: SyncGroupMethods): undefined | false | SyncCode;
+    getSyncCode(mustSupport?: DtoSyncGroupMethods): undefined | false | SyncCode;
     /**
-     * The MeasureParam class is re-used for different purposes. In Features it is used
+     * The DtoMeasureParam class is re-used for different purposes. In Features it is used
      * to indicate which stretch measures inside Models shall be affected by this state
      * of this Feature. Hence only the code property is used.
      */
@@ -97,12 +98,10 @@ export declare class _CfgFeatureInternal {
      * @throws Will throw if options have not yet been generated. This should be impossible
      * as nonexisting children can not call their parent.
      */
-    _childHasChanged: (childOption: _CfgOptionInternal, bubbleMode: ProductConfigurationBubbleMode) => Promise<void>;
-    getApiSelection: () => {
-        [index: string]: SelectedOption;
-    } | undefined;
+    _childHasChanged: (childOption: _CfgOptionInternal, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
+    getDtoConf: (includeExtendedData: boolean) => DtoConfFeature;
     setApiSelection: (apiOptionSelectionMap: {
-        [index: string]: SelectedOption;
+        [index: string]: DtoSelectedOption;
     } | undefined) => Promise<boolean>;
     /** Pushes to refresh stretch. Does not cause validation. */
     pushStretch: () => Promise<boolean>;
@@ -129,7 +128,7 @@ export declare class _CfgFeatureInternal {
 }
 export declare class CfgFeature {
     readonly _internal: _CfgFeatureInternal;
-    static make(rawFeature: Feature, allRawFeatures: Feature[], key: string, parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature;
+    static make(rawFeature: DtoFeature, allRawFeatures: DtoFeature[], key: string, parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature;
     /**
      * Makes an object wrapping the passed object. This is not a clone method,
      * it is a method to make a new outer reference. Like a shallow copy.