@configura/web-api 2.0.0-alpha.16 → 2.0.0-alpha.17

package/dist/CfgProduct.d.ts

@@ -101,6 +101,7 @@ export declare class _CfgProductInternal {
      * change.
      */
     _updateAdditionalProdRef(p: DtoAdditionalProductRef): void;
+    get hasRootFeaturesChanged(): boolean;
     get description(): string | undefined;
     get rootNodeSources(): RootNodeSource[] | undefined;
     get mtrlApplications(): DtoMtrlApplication[] | undefined;
@@ -224,6 +225,18 @@ export declare class CfgProduct {
      *  assumed to always be legal.
      */
     setSelected: (v: boolean) => Promise<boolean>;
+    /**
+     * Functional selection is a Catalogues feature where selecting Options on Features result in that you
+     * "jump" to another Product as a result of the Validate call. You normally do not notice that a functional
+     * selection has occurred except for the styleNr changing. Functional selection can change which Features
+     * from the original product call are used as root Features. This can in turn affect if serialized
+     * configuration can be applied or not.
+     *
+     * The SDK can currently only apply serialized configuration if the list of root Features has not changed.
+     * For this reason, when functional selection has happened, extracting data for external systems might work
+     * well, but reapplying back into Stage will probably fail.
+     */
+    get hasRootFeaturesChanged(): boolean;
     get rawProductData(): CfgProductData;
     get uuid(): string;
     get unit(): LengthUnit;

package/dist/CfgProduct.js

@@ -456,6 +456,10 @@ export class _CfgProductInternal {
             this._selected = p.optional ? false : undefined;
         }
     }
+    get hasRootFeaturesChanged() {
+        return (this._configuration._internal.hasRootFeaturesChanged ||
+            this.additionalProducts.some((p) => p._internal.hasRootFeaturesChanged));
+    }
     get description() {
         var _a, _b;
         return (_b = (_a = this._additionalProductRef) === null || _a === void 0 ? void 0 : _a.refDescription) !== null && _b !== void 0 ? _b : this._rawProductData.description;
@@ -772,6 +776,21 @@ export class CfgProduct {
     get visible() {
         return this._internal.visible;
     }
+    // A similar text to the one below exists in global-message-managers.md and should be kept in sync.
+    /**
+     * Functional selection is a Catalogues feature where selecting Options on Features result in that you
+     * "jump" to another Product as a result of the Validate call. You normally do not notice that a functional
+     * selection has occurred except for the styleNr changing. Functional selection can change which Features
+     * from the original product call are used as root Features. This can in turn affect if serialized
+     * configuration can be applied or not.
+     *
+     * The SDK can currently only apply serialized configuration if the list of root Features has not changed.
+     * For this reason, when functional selection has happened, extracting data for external systems might work
+     * well, but reapplying back into Stage will probably fail.
+     */
+    get hasRootFeaturesChanged() {
+        return this._internal.hasRootFeaturesChanged;
+    }
     get rawProductData() {
         return this._internal.rawProductData;
     }

package/dist/io/CfgHistoryManager.js

@@ -59,6 +59,12 @@ export class CfgHistoryManager extends CfgWindowEventManager {
      */
     send(messageKey, data) {
         const { qsKeyValues, message, mode } = data;
+        const warnings = this.getWarnings();
+        if (warnings.length !== 0) {
+            console.warn("History updating blocked by warnings");
+            warnings.forEach((w) => console.warn(w));
+            return;
+        }
         for (const keyValue of qsKeyValues) {
             this._aggregatedQsKeyValues.set(keyValue[0], keyValue[1]);
         }

package/dist/io/CfgIOManager.d.ts

@@ -1,3 +1,4 @@
+import { CfgIOWarningSupplier } from "./CfgIOWarningSupplier";
 declare type ConfiguraAttribute = "C0nf1gura";
 declare type ConfiguraShebang = "arug1fn0C";
 declare const CONFIGURA_ATTRIBUTE: ConfiguraAttribute;
@@ -17,6 +18,10 @@ export declare type CfgIOContainer = {
  * Base class for classes handling input and output in globally shared environments.
  */
 export declare abstract class CfgIOManager<S> {
+    private _warningSuppliers;
+    addWarningSupplier(supplier: CfgIOWarningSupplier): void;
+    removeWarningSupplier(supplier: CfgIOWarningSupplier): void;
+    getWarnings(): string[];
     /**
      * Listen for the message messageKey being received.
      */

package/dist/io/CfgIOManager.js

@@ -18,12 +18,31 @@ const hasConfiguraAttribute = (data) => {
  */
 export class CfgIOManager {
     constructor() {
+        this._warningSuppliers = [];
         // A lock to avoid circular write. Asynchronous conditions can make this not be enough.
         // Avoid creating pre-conditions where this can happen.
         this._receiveInProgress = false;
         this._messageListeners = [];
         this._getIndexOfMessageListener = (l) => this._messageListeners.findIndex((item) => l === item.l);
     }
+    addWarningSupplier(supplier) {
+        this._warningSuppliers.push(supplier);
+    }
+    removeWarningSupplier(supplier) {
+        const i = this._warningSuppliers.indexOf(supplier);
+        if (i === -1) {
+            return;
+        }
+        this._warningSuppliers.splice(i, 1);
+    }
+    getWarnings() {
+        return this._warningSuppliers.reduce((aggregated, supplier) => {
+            for (const warning of supplier.getWarnings()) {
+                aggregated.push(warning);
+            }
+            return aggregated;
+        }, []);
+    }
     /**
      * Listen for the message messageKey being received.
      */

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -1,6 +1,7 @@
 import { DtoAdditionalProductConfiguration, DtoProductConf } from "../CatalogueAPI.js";
 import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
 import { CfgIOManager } from "./CfgIOManager.js";
+import { CfgIOWarningSupplier } from "./CfgIOWarningSupplier.js";
 export declare const isCfgProdConfMessage: (data: unknown) => data is CfgProdConfMessageV1 | CfgProdConfMessageV2;
 export declare type CfgProdConfMessageV1 = {
     version: "1.0";
@@ -27,16 +28,17 @@ declare type ProdConfCallback = (conf: DtoProductConf) => Promise<void>;
 /**
  * Base class for connecting the product configuration to an IO channel
  */
-export declare abstract class CfgIOProdConfConnector<S> {
-    private readonly _ioManager;
+export declare abstract class CfgIOProdConfConnector<S> implements CfgIOWarningSupplier {
+    protected readonly _ioManager: CfgIOManager<S>;
     private readonly _includeExtendedDataInSend;
     private readonly _includeProdParamsInSend;
-    private _product;
+    protected _product: CfgProduct | undefined;
     private _stopListenToMessage;
     private _stopListenToProdConf;
-    constructor(_ioManager: CfgIOManager<S>, _includeExtendedDataInSend: boolean, // Only v2.0
+    constructor(_ioManager: CfgIOManager<S>, _includeExtendedDataInSend: boolean, // Only for v2.0
     _includeProdParamsInSend: boolean);
-    destroy: () => void;
+    destroy(): void;
+    getWarnings(): string[];
     setProduct: (product: CfgProduct | undefined) => Promise<void>;
     private _send;
     protected getInitialProdConf(): DtoProductConf | undefined;

package/dist/io/CfgIOProdConfConnector.js

@@ -24,19 +24,14 @@ export const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
  * Base class for connecting the product configuration to an IO channel
  */
 export class CfgIOProdConfConnector {
-    constructor(_ioManager, _includeExtendedDataInSend, // Only v2.0
-    _includeProdParamsInSend // Only v2.0
+    constructor(_ioManager, _includeExtendedDataInSend, // Only for v2.0
+    _includeProdParamsInSend // Only for v2.0
     ) {
         this._ioManager = _ioManager;
         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;
@@ -88,6 +83,22 @@ export class CfgIOProdConfConnector {
             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);
+        _ioManager.addWarningSupplier(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._ioManager.removeWarningSupplier(this);
+    }
+    getWarnings() {
+        const product = this._product;
+        if (product !== undefined && product.hasRootFeaturesChanged) {
+            return [
+                "In at least one of the Products, Functional Selection has taken place, thereby changing what root Features are used. The SDK can not yet apply a serialized configuration in these cases. Extracting this data from the SDK for external applications can work, but reinserting the data into Stage will most likely fail.",
+            ];
+        }
+        return [];
     }
     getInitialProdConf() {
         return undefined;

package/dist/io/CfgIOWarningSupplier.d.ts

@@ -0,0 +1,4 @@
+export interface CfgIOWarningSupplier {
+    getWarnings(): string[];
+}
+//# sourceMappingURL=CfgIOWarningSupplier.d.ts.map

package/dist/io/CfgIOWarningSupplier.js

@@ -0,0 +1 @@
+export {};

package/dist/io/CfgWindowMessageManager.js

@@ -70,6 +70,10 @@ export class CfgWindowMessageManager extends CfgWindowEventManager {
         const container = CfgIOManager.makeContainer({
             [messageKey]: data,
         });
+        const warnings = this.getWarnings();
+        if (warnings.length !== 0) {
+            warnings.forEach((w) => console.warn(w));
+        }
         for (const remoteEnd of this._remoteEnds) {
             remoteEnd.postMessage(container, this._targetOrigin);
         }

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -20,6 +20,7 @@ export declare class _CfgProductConfigurationInternal {
     readonly allRawFeatures: DtoFeature[];
     readonly parentProduct: _CfgProductInternal;
     readonly rootProduct: _CfgProductInternal;
+    private readonly _initialRootFeatureRefs;
     static _makeUninitialized(rootFeatureRefs: DtoFeatureRef[], allRawFeatures: DtoFeature[], // Flat packed. All the features that can appear anyplace in the selection tree.
     parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): _CfgProductConfigurationInternal;
     private constructor();
@@ -50,6 +51,12 @@ export declare class _CfgProductConfigurationInternal {
     tryMatchSelection: (other: _CfgProductConfigurationInternal, descriptionMatch: boolean | undefined, validate: boolean) => Promise<boolean>;
     /** Only selected features. */
     _getFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
+    private _hasRootFeaturesChanged;
+    /**
+     * True if what root Features are used is not the same as at initial load.
+     * This means that functional selection has happened.
+     */
+    get hasRootFeaturesChanged(): boolean;
     populateFeatures: (rootFeatureRefs: DtoFeatureRef[]) => void;
     setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit) => Promise<boolean>;
 }

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -20,10 +20,11 @@ import { syncCfgFeatures } from "./utilitiesProductConfiguration.js";
  */
 export class _CfgProductConfigurationInternal {
     constructor(allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
-    parentProduct, rootProduct) {
+    parentProduct, rootProduct, _initialRootFeatureRefs) {
         this.allRawFeatures = allRawFeatures;
         this.parentProduct = parentProduct;
         this.rootProduct = rootProduct;
+        this._initialRootFeatureRefs = _initialRootFeatureRefs;
         this.key = "~";
         this._rootFeatureRefs = [];
         this._features = [];
@@ -113,8 +114,10 @@ export class _CfgProductConfigurationInternal {
             agg.push(...feature._internal._getFeaturesWithCode(code));
             return agg;
         }, []);
+        this._hasRootFeaturesChanged = false;
         this.populateFeatures = (rootFeatureRefs) => {
             this._rootFeatureRefs = rootFeatureRefs;
+            this._hasRootFeaturesChanged = !compareArrays(this._initialRootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code);
             this._features = syncCfgFeatures(rootFeatureRefs, this._features, this.allRawFeatures, this, this, this.parentProduct, this.rootProduct);
         };
         this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => __awaiter(this, void 0, void 0, function* () {
@@ -198,7 +201,7 @@ export class _CfgProductConfigurationInternal {
     }
     static _makeUninitialized(rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
     parentProduct, rootProduct) {
-        const configuration = new this(allRawFeatures, parentProduct, rootProduct);
+        const configuration = new this(allRawFeatures, parentProduct, rootProduct, rootFeatureRefs);
         configuration.populateFeatures(rootFeatureRefs);
         return configuration;
     }
@@ -217,6 +220,13 @@ export class _CfgProductConfigurationInternal {
             features[i] = CfgFeature._makeNewRefFrom(featureInternal);
         }
     }
+    /**
+     * True if what root Features are used is not the same as at initial load.
+     * This means that functional selection has happened.
+     */
+    get hasRootFeaturesChanged() {
+        return this._hasRootFeaturesChanged;
+    }
 }
 export class CfgProductConfiguration {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/web-api",
-	"version": "2.0.0-alpha.16",
+	"version": "2.0.0-alpha.17",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "2.0.0-alpha.16"
+		"@configura/web-utilities": "2.0.0-alpha.17"
 	},
-	"gitHead": "8c03272c5c4eb3445ad9a06dda0abe1d1fefab49"
+	"gitHead": "7894d44db1eb25eab4affba49513cc56ac83fd75"
 }