@configura/web-api 2.0.0-alpha.9 → 2.1.0-alpha.0

package/dist/CfgProduct.js

@@ -9,13 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { AggregatedLoadingObservable, assert, assertDefined, augmentErrorMessage, compareArrays, count, Observable, toLengthUnit, } from "@configura/web-utilities";
 import { CfgMeasureDefinition } from "./CfgMeasure.js";
-import { convertDtoConfProdToV1 } from "./ConfigurationConverter.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
 import { CfgProductConfiguration } from "./productConfiguration/CfgProductConfiguration.js";
 import { collectAdditionalProductRefs } from "./productConfiguration/utilitiesProductConfiguration.js";
 import { wrapWithCache } from "./productLoader.js";
 import { SyncGroupsHandler } from "./syncGroups/SyncGroupsHandler.js";
-import { comparePricesObjects, correctDefaultsOnCatalogueParams, isSameCatalogueParams, isSameProductRef, makeProductKey, } from "./utilitiesCatalogueData.js";
+import { compareCfgProductData, correctDefaultsOnCatalogueParams, isSameCatalogueParams, isSameProductRef, makeProductKey, } from "./utilitiesCatalogueData.js";
+import { CfgProdConfParts, convertDtoProductConfToV1, isAdditionalProductConfiguration, isProductConf, } from "./utilitiesConfiguration.js";
 function completeSettings(incompleteSettings) {
     var _a;
     return {
@@ -52,7 +52,7 @@ function isDescriptionMatch(l, r) {
  * the class that should be used and interacted with.
  */
 export class _CfgProductInternal {
-    constructor(initSuccess, initFail, _productLoaderRaw, prodParams, settings, optional, selected, rootFeatureRefs, allRawFeatures, uuid, _rawUnit, _rawProductData, apiSelection, loadingObservable, parent, root, _additionalProductRef, _syncGroupHandler) {
+    constructor(initSuccess, initFail, _productLoaderRaw, prodParams, settings, optional, selected, rootFeatureRefs, rawFeatures, notes, uuid, _rawUnit, _rawProductData, apiSelection, loadingObservable, parent, root, _additionalProductRef, _syncGroupHandler) {
         var _a;
         this._productLoaderRaw = _productLoaderRaw;
         this.prodParams = prodParams;
@@ -66,15 +66,26 @@ export class _CfgProductInternal {
         this._syncGroupHandler = _syncGroupHandler;
         this._destroyed = false;
         this.additionalProducts = [];
+        this._notes = new Map();
         this.changeObservable = new Observable();
+        /** Mark this and its descendants as destroyed and remove all listeners */
         this.destroy = () => {
+            var _a;
             this._destroyed = true;
             this.changeObservable.stopAllListen();
             this.configuration.stopAllListenForChange();
-            for (const additionalProduct of this.additionalProducts || []) {
+            for (const additionalProduct of (_a = this.additionalProducts) !== null && _a !== void 0 ? _a : []) {
                 additionalProduct.destroy();
             }
         };
+        /**
+         * Reset will reset the product to its initial state
+         */
+        this.reset = () => __awaiter(this, void 0, void 0, function* () {
+            if (this._initialClone !== undefined) {
+                yield this.copyFrom(this._initialClone, true);
+            }
+        });
         this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             if (bubbleMode === CfgProductBubbleMode.Stop) {
                 return;
@@ -93,7 +104,7 @@ export class _CfgProductInternal {
             if (bubbleMode === CfgProductBubbleMode.ToRootAndBubbleSelected &&
                 this.optional &&
                 !this.selected) {
-                yield this.setSelected(true, bubbleMode);
+                yield this.setSelected(true, bubbleMode, false);
                 return;
             }
             yield this._notifyAllOfChange(bubbleMode, committed);
@@ -140,18 +151,26 @@ export class _CfgProductInternal {
                     return;
             }
         });
-        this.getDtoConf = (includeExtendedData, includeProductParams) => {
+        this.getDtoConf = (include) => {
+            var _a;
             const conf = {};
-            const features = this.configuration._internal.getDtoConf(includeExtendedData);
+            const features = this.configuration._internal.getDtoConf((include & CfgProdConfParts.ExtendedData) === CfgProdConfParts.ExtendedData);
             if (0 < features.length) {
                 conf.features = features;
             }
-            if (includeProductParams) {
+            if ((include & CfgProdConfParts.ProdParams) === CfgProdConfParts.ProdParams) {
                 conf.prodParams = this.prodParams;
             }
+            // Only store the syncGroupState for the root product. The same state
+            // is used for the entire product, including the additional product,
+            // so no need to store it for additional products.
+            if ((include & CfgProdConfParts.SyncGroupState) === CfgProdConfParts.SyncGroupState &&
+                this.parent === undefined) {
+                conf.syncGroupState = (_a = this.syncGroupHandler) === null || _a === void 0 ? void 0 : _a.getCompactSyncGroupState();
+            }
             const additionalProducts = this.additionalProducts;
             if (0 < additionalProducts.length) {
-                conf.additionalProducts = additionalProducts.map((p) => p._internal.getDtoConf(includeExtendedData, includeProductParams));
+                conf.additionalProducts = additionalProducts.map((p) => p._internal.getDtoConf(include));
             }
             if (this.isAdditionalProduct) {
                 const refKey = this.refKey;
@@ -165,15 +184,25 @@ export class _CfgProductInternal {
             return conf;
         };
         this.setDtoConf = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.setApiSelection(convertDtoConfProdToV1(s), doValidate, productLoaderForGroupedLoad);
+            // The DtoProdConf format can contain a sync group state, but
+            // not the DtoAdditionalProductConfiguration format. So we apply
+            // any passed state here.
+            if (this.root === this) {
+                const syncGroupHandler = this.syncGroupHandler;
+                const newSyncGroupState = s.syncGroupState;
+                if (syncGroupHandler !== undefined && newSyncGroupState !== undefined) {
+                    syncGroupHandler.setCompactSyncGroupState(newSyncGroupState);
+                }
+            }
+            return yield this.setApiSelection(convertDtoProductConfToV1(s), doValidate, productLoaderForGroupedLoad);
         });
         this.setApiSelection = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
             return yield this._setApiSelectionWithOtherProduct(s, doValidate, productLoaderForGroupedLoad, undefined);
         });
         this.copyFrom = (source, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._setApiSelectionWithOtherProduct(convertDtoConfProdToV1(source.getDtoConf(false, false)), doValidate, productLoaderForGroupedLoad, source);
+            return yield this._setApiSelectionWithOtherProduct(convertDtoProductConfToV1(source.getDtoConf(CfgProdConfParts.NoExtra)), doValidate, productLoaderForGroupedLoad, source);
         });
-        this._setApiSelectionWithOtherProduct = (s, doValidate, productLoaderForGroupedLoad, sourceProduct) => __awaiter(this, void 0, void 0, function* () {
+        this._setApiSelectionWithOtherProduct = (productConfiguration, doValidate, productLoaderForGroupedLoad, sourceProduct) => __awaiter(this, void 0, void 0, function* () {
             // Wrap with cache will make getProduct for this function call use the same server call
             // for the same product with the same params. Used for getProduct (when a new additional
             // product is loaded) and postValidate.
@@ -181,21 +210,42 @@ export class _CfgProductInternal {
                 productLoaderForGroupedLoad || wrapWithCache(this._productLoaderRaw);
             let change = false;
             if (sourceProduct !== undefined) {
-                this._rawProductData = sourceProduct.rawProductData;
-                this.configuration._internal.populateFeatures(sourceProduct.configuration.rootFeatureRefs);
-                change = true; // We can not know if this is an actual change, so we assume it is
+                if (!compareCfgProductData(this._rawProductData, sourceProduct.rawProductData)) {
+                    this._rawProductData = sourceProduct.rawProductData;
+                    change = true;
+                }
+                if (this.configuration._internal.addRawFeatures(sourceProduct.configuration.rawFeatures, false)) {
+                    change = true;
+                }
+                if (this.configuration._internal.populateFeatures(sourceProduct.configuration.rootFeatureRefs)) {
+                    change = true;
+                }
+                const targetNotes = this._notes;
+                const sourceNotes = sourceProduct._notes;
+                for (const targetKey of targetNotes.keys()) {
+                    if (!sourceNotes.has(targetKey)) {
+                        targetNotes.delete(targetKey);
+                        change = true;
+                    }
+                }
+                for (const [sourceKey, sourceNote] of sourceNotes) {
+                    if (!targetNotes.has(sourceKey)) {
+                        targetNotes.set(sourceKey, sourceNote);
+                        change = true;
+                    }
+                }
             }
-            const configurationChange = yield this.configuration._internal.setApiSelection(s.selOptions, false);
+            const configurationChange = yield this.configuration._internal.setApiSelection(productConfiguration.selOptions, false);
             if (configurationChange) {
                 change = true;
             }
             if (this.optional) {
-                if (yield this.setSelected(s.selected !== false, CfgProductBubbleMode.Stop)) {
+                if (yield this.setSelected(productConfiguration.selected !== false, CfgProductBubbleMode.Stop, false)) {
                     change = true;
                 }
             }
-            yield this._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad);
-            const apiSelectionAdditionalProducts = s.additionalProducts || [];
+            yield this._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad, productConfiguration);
+            const apiSelectionAdditionalProducts = productConfiguration.additionalProducts || [];
             const additionalProducts = this.additionalProducts.slice();
             const additionalProductsCount = additionalProducts.length;
             const apiSelectionAdditionalProductsCount = apiSelectionAdditionalProducts.length;
@@ -248,7 +298,7 @@ export class _CfgProductInternal {
                 productLoaderForGroupedLoad || wrapWithCache(this._productLoaderRaw);
             let change = false;
             if (this.optional && other.optional) {
-                if (yield this.setSelected(other.selected, CfgProductBubbleMode.Stop)) {
+                if (yield this.setSelected(other.selected, CfgProductBubbleMode.Stop, false)) {
                     change = true;
                 }
             }
@@ -312,7 +362,10 @@ export class _CfgProductInternal {
             const token = this.loadingObservable.startChildLoading();
             this._revalidateInProgressToken = token;
             try {
-                const response = yield productLoader.postValidate(correctDefaultsOnCatalogueParams(this.prodParams), { selOptions: configuration.getApiSelection() });
+                const response = yield productLoader.postValidate(correctDefaultsOnCatalogueParams(this.prodParams), {
+                    selOptions: configuration._internal.getApiSelection(),
+                    knownFeatureCodes: configuration.rawFeatures.map((f) => f.code),
+                });
                 // The revalidateInProgressToken is used to know if some other revalidate
                 // call has happened after this call, thereby making this call obsolete.
                 // This is a bit crude in that it does not actually cancel previous validate
@@ -331,18 +384,17 @@ export class _CfgProductInternal {
                 if (this._destroyed) {
                     return false;
                 }
-                const { productData, rootFeatureRefs } = response;
-                const pricesUpdated = !comparePricesObjects(this.prices, productData.partsData.prices);
+                const { productData, rootFeatureRefs, features, notes } = response;
+                if (notes !== undefined) {
+                    this.addNotes(notes.values());
+                }
                 this._rawProductData = productData;
+                configuration._internal.addRawFeatures(features, true);
                 if (rootFeatureRefs !== undefined) {
                     configuration._internal.populateFeatures(rootFeatureRefs);
                 }
-                if (pricesUpdated) {
-                    this._configuration._internal._freshRefDescendants();
-                    this._configuration = CfgProductConfiguration._makeNewRefFrom(this._configuration._internal);
-                }
                 yield configuration._internal.setApiSelection(productData.partsData.selOptions || [], false);
-                yield this._syncAndLoadAdditionalProducts(productLoader);
+                yield this._syncAndLoadAdditionalProducts(productLoader, undefined);
                 if (this._destroyed) {
                     return false;
                 }
@@ -350,7 +402,7 @@ export class _CfgProductInternal {
                 return true;
             }
             catch (e) {
-                throw augmentErrorMessage(e, "Validate product configuration request failure");
+                throw augmentErrorMessage(e, `Validate product configuration request (${this.prodParams.partNumber}) failure`);
             }
             finally {
                 this.loadingObservable.stopChildLoading(token);
@@ -360,7 +412,7 @@ export class _CfgProductInternal {
          * Based on this configuration find what additional products should be shown and not, unload
          * (i.e. destroy) those that should no longer be shown, load the new ones.
          */
-        this._syncAndLoadAdditionalProducts = (productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
+        this._syncAndLoadAdditionalProducts = (productLoaderForGroupedLoad, initialProductConfiguration) => __awaiter(this, void 0, void 0, function* () {
             const { _productLoaderRaw: productLoaderRaw, rawProductData: productData, configuration, additionalProducts: currentAdditionalProducts, } = this;
             const additionalProductRefs = [
                 ...(productData.additionalProductRefs || []),
@@ -402,10 +454,17 @@ export class _CfgProductInternal {
                     change = true;
                 }
                 const newAdditionalProducts = yield Promise.all(additionalProductRefs.map((p) => (() => __awaiter(this, void 0, void 0, function* () {
+                    var _c;
                     const additionalProductRef = p.prodRef;
+                    const refKey = additionalProductRef.refKey;
+                    const additionalProductInitialProductConfiguration = (_c = initialProductConfiguration === null || initialProductConfiguration === void 0 ? void 0 : initialProductConfiguration.additionalProducts) === null || _c === void 0 ? void 0 : _c.find((aP) => refKey === aP.refKey);
+                    if (initialProductConfiguration !== undefined &&
+                        additionalProductInitialProductConfiguration === undefined) {
+                        console.warn(`Did not find initial product configuration for additional product with refKey ${refKey}`);
+                    }
                     return {
                         originalIndex: p.originalIndex,
-                        product: CfgProduct._makeNewRefFrom(yield _CfgProductInternal.make(productLoaderRaw, productLoaderForGroupedLoad, Object.assign(Object.assign({}, additionalProductRef.catId), { cid: this.prodParams.cid, lang: this.prodParams.lang, partNumber: additionalProductRef.partNumber }), this.settings, additionalProductRef.optional === true, this.loadingObservable, this, this.root, additionalProductRef)),
+                        product: CfgProduct._makeNewRefFrom(yield _CfgProductInternal.make(productLoaderRaw, productLoaderForGroupedLoad, Object.assign(Object.assign({}, additionalProductRef.catId), { cid: this.prodParams.cid, lang: this.prodParams.lang, partNumber: additionalProductRef.partNumber }), this.settings, additionalProductRef.optional === true, this.loadingObservable, this, this.root, additionalProductRef, additionalProductInitialProductConfiguration)),
                     };
                 }))()));
                 if (this._destroyed) {
@@ -423,19 +482,28 @@ export class _CfgProductInternal {
         this.root = root !== null && root !== void 0 ? root : this;
         this.key = makeProductKey(Object.assign(Object.assign({}, prodParams), { partNumber: (_a = _additionalProductRef === null || _additionalProductRef === void 0 ? void 0 : _additionalProductRef.refKey) !== null && _a !== void 0 ? _a : prodParams.partNumber }));
         this._selected = optional ? selected : undefined;
-        this.isAdditionalProduct = parent !== undefined;
-        this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, allRawFeatures, apiSelection, this, this.root);
+        this.isAdditionalProduct = _additionalProductRef !== undefined;
+        if (notes !== undefined) {
+            this.addNotes(notes);
+        }
+        this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, rawFeatures, apiSelection, this, this.root);
     }
     get selected() {
         return this._selected !== false;
     }
+    /**
+     * Please note that cloning an additional product will make the clone believe is is
+     * an additional product, even if it has no parent and root.
+     * Providing the parent and root of what you clone as arguments is unwise as it will
+     * make changes you do on the clone be propagated up to the original non-clone root product.
+     */
     clone(parent, root) {
         return __awaiter(this, void 0, void 0, function* () {
             const product = yield new Promise((initSuccess, initFail) => {
                 var _a;
                 const p = new _CfgProductInternal(() => {
                     initSuccess(p);
-                }, initFail, this._productLoaderRaw, this.prodParams, this.settings, this.optional, this.selected, this._configuration.rootFeatureRefs, this._configuration.allRawFeatures, this.uuid, this._rawUnit, this._rawProductData, this.configuration.getApiSelection(), new AggregatedLoadingObservable(), parent, root, this._additionalProductRef, (_a = this._syncGroupHandler) === null || _a === void 0 ? void 0 : _a.clone());
+                }, initFail, this._productLoaderRaw, this.prodParams, this.settings, this.optional, this.selected, this._configuration.rootFeatureRefs, this._configuration.rawFeatures, this._notes.values(), this.uuid, this._rawUnit, this._rawProductData, this.configuration._internal.getApiSelection(), new AggregatedLoadingObservable(), parent, root, this._additionalProductRef, (_a = this._syncGroupHandler) === null || _a === void 0 ? void 0 : _a.clone());
             });
             for (const additionalProduct of this.additionalProducts) {
                 product.additionalProducts.push(CfgProduct._makeNewRefFrom(yield additionalProduct._internal.clone(product, root || product)));
@@ -443,12 +511,56 @@ export class _CfgProductInternal {
             return product;
         });
     }
+    /**
+     * Internal use. Used when this product is an additional product, and
+     * changing a parent product has made the settings for this product
+     * change.
+     */
     _updateAdditionalProdRef(p) {
         this._additionalProductRef = p;
         if (p.optional !== this.optional) {
             this._selected = p.optional ? false : undefined;
         }
     }
+    /**
+     * Return a DtoNode using noteRef as a key.
+     * Throws an error if no note is found.
+     */
+    getNote(noteRef) {
+        const note = this._notes.get(noteRef);
+        if (note === undefined) {
+            throw new Error(`Note with noteRef ${noteRef} not found.`);
+        }
+        return note;
+    }
+    /**
+     * noteRefs is a list of keys coming from CfgOption, CfgFeature or CfgProduct.
+     * The keys are used to get a DtoNote[] from notes at CfgProduct.
+     */
+    getNotes(noteRefs) {
+        return noteRefs.map((noteRef) => this.getNote(noteRef));
+    }
+    addNotes(notes) {
+        for (const note of notes) {
+            const code = note.code;
+            if (!code) {
+                throw new Error("Note with no code");
+            }
+            this._notes.set(code, note);
+        }
+    }
+    get notes() {
+        var _a;
+        return this.getNotes((_a = this.rawProductData.noteRefs) !== null && _a !== void 0 ? _a : []);
+    }
+    get miscFiles() {
+        var _a;
+        return (_a = this._rawProductData.miscFiles) !== null && _a !== void 0 ? _a : [];
+    }
+    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;
@@ -523,16 +635,31 @@ export class _CfgProductInternal {
     get optional() {
         return this._selected !== undefined;
     }
-    setSelected(v, bubbleMode) {
+    setSelected(selected, bubbleMode, interactive) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.optional) {
                 console.warn("This product is not optional. Nothing will happen");
                 return false;
             }
-            if (this._selected === v) {
+            if (this._selected === selected) {
                 return false;
             }
-            this._selected = v;
+            // Vitally important that this happens before the call to reset,
+            // so that the reset won't cause infinite loops
+            this._selected = selected;
+            if (interactive) {
+                if (selected) {
+                    const syncGroupHandler = this.syncGroupHandler;
+                    if (syncGroupHandler !== undefined) {
+                        yield syncGroupHandler.init(this.root, wrapWithCache(this._productLoaderRaw));
+                    }
+                }
+                else {
+                    yield this.reset();
+                    // In case a passed initial configuration has made it reset to selected
+                    this._selected = selected;
+                }
+            }
             yield this._notifyAllOfChange(bubbleMode, true);
             return true;
         });
@@ -585,33 +712,66 @@ export class _CfgProductInternal {
     }
 }
 _CfgProductInternal.make = (productLoaderRaw, productLoaderForGroupedLoad, // Used when instantiating the current product
-prodParams, settings, optional, loadingObservable, parent, root, additionalProductRef) => __awaiter(void 0, void 0, void 0, function* () {
+prodParams, settings, optional, loadingObservable, parent, root, additionalProductRef, initialProductConfiguration) => __awaiter(void 0, void 0, void 0, function* () {
     // Wrap with cache will make getProduct for this function call use the same server call
     // for the same product with the same params. Not retained for future calls, only used
     // at this initial load.
     productLoaderForGroupedLoad =
         productLoaderForGroupedLoad || wrapWithCache(productLoaderRaw);
-    const syncGroupHandler = root === undefined
-        ? SyncGroupsHandler.make(settings.syncGroupsApplyMode, loadingObservable)
-        : undefined;
+    let syncGroupHandler = undefined;
+    // No root means we are root. We only create SyncGroupsHandler if this is the root product
+    if (root === undefined) {
+        let initialSyncGroupsState = undefined;
+        // DtoProductConf supports containing the sync group state, but the old
+        // DtoAdditionalProductConfiguration does not
+        if (initialProductConfiguration !== undefined &&
+            isProductConf(initialProductConfiguration)) {
+            initialSyncGroupsState = initialProductConfiguration.syncGroupState;
+        }
+        syncGroupHandler = SyncGroupsHandler.make(settings.syncGroupsApplyMode, loadingObservable, initialSyncGroupsState);
+    }
     try {
-        const productResponse = yield productLoaderForGroupedLoad.getProduct(correctDefaultsOnCatalogueParams(prodParams));
-        const { productData, rootFeatureRefs, features: allRawFeatures, uuid, unit, } = productResponse;
+        const defaultCorrectedProdParams = correctDefaultsOnCatalogueParams(prodParams);
+        let initialProductConfigurationV1 = undefined;
+        if (initialProductConfiguration !== undefined) {
+            if (isProductConf(initialProductConfiguration)) {
+                initialProductConfigurationV1 = convertDtoProductConfToV1(initialProductConfiguration);
+            }
+            else if (isAdditionalProductConfiguration(initialProductConfiguration)) {
+                initialProductConfigurationV1 = initialProductConfiguration;
+            }
+        }
+        const productResponse = yield (initialProductConfigurationV1
+            ? productLoaderForGroupedLoad.postValidate(defaultCorrectedProdParams, {
+                knownFeatureCodes: [],
+                selOptions: initialProductConfigurationV1.selOptions,
+            })
+            : productLoaderForGroupedLoad.getProduct(defaultCorrectedProdParams));
+        const { productData, rootFeatureRefs, features: rawFeatures, notes, uuid, unit, } = productResponse;
+        const initiallySelected = !optional || (initialProductConfigurationV1 === null || initialProductConfigurationV1 === void 0 ? void 0 : initialProductConfigurationV1.selected) === true;
         const product = yield new Promise((initSuccess, initFail) => {
+            var _a;
             const p = new _CfgProductInternal(() => {
                 // We absolutely do not want anyone to assign to this._configuration. So we want that field private.
                 // But we can not set the api selection synchronously. And the product configuration needs "this". So we use this callback.
                 // Feel free to find a nicer more readable solution :)
                 initSuccess(p);
-            }, initFail, productLoaderRaw, prodParams, settings, optional, !optional, rootFeatureRefs, allRawFeatures, uuid, unit, productData, productData.partsData.selOptions || [], loadingObservable, parent, root, additionalProductRef, syncGroupHandler);
+            }, initFail, productLoaderRaw, prodParams, settings, optional, initiallySelected, rootFeatureRefs !== null && rootFeatureRefs !== void 0 ? rootFeatureRefs : [], rawFeatures, notes === null || notes === void 0 ? void 0 : notes.values(), uuid, unit, productData, (_a = productData.partsData.selOptions) !== null && _a !== void 0 ? _a : [], loadingObservable, parent, root, additionalProductRef, syncGroupHandler);
         });
-        yield product._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad);
-        // Product is guaranteed to be root
-        yield (syncGroupHandler === null || syncGroupHandler === void 0 ? void 0 : syncGroupHandler.init(product, productLoaderForGroupedLoad));
+        yield product._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad, initialProductConfigurationV1);
+        product._initialClone = yield product.clone();
+        if (syncGroupHandler !== undefined && !initialProductConfiguration) {
+            // As syncGroupHandler is only set for root product we know that we will init with root.
+            // If we have an initialProductConfiguration we do not run init for the syncGroups.
+            // The idea with an initial configuration is that the product should look as it did when
+            // the configuration was saved. Not running init does that. Also, the DtoProductConf
+            // object can contain a sync state which is then used to populate the sync state.
+            yield syncGroupHandler.init(product, productLoaderForGroupedLoad);
+        }
         return product;
     }
     catch (e) {
-        throw augmentErrorMessage(e, "Load product request failure");
+        throw augmentErrorMessage(e, `Load product request (${prodParams.partNumber}) failure`);
     }
 });
 export class CfgProduct {
@@ -630,7 +790,7 @@ export class CfgProduct {
          * Setting this does not cause a validation call as toggling an optional additional product is
          *  assumed to always be legal.
          */
-        this.setSelected = (v) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setSelected(v, CfgProductBubbleMode.ToRootAndBubbleSelected); });
+        this.setSelected = (v) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setSelected(v, CfgProductBubbleMode.ToRootAndBubbleSelected, true); });
         /**
          * Experimental. Additional products lacks descriptions or keys that are suitably for structure
          * compare, so we use strict-order when trying to match the additional products. This makes
@@ -650,11 +810,40 @@ export class CfgProduct {
          * Gets what selections has been made on the product, recursively including product
          * configuration, optional products and additional products. Used when a full view of all
          * selections on a product is needed, such as when doing Render or Export.
+         * @deprecated getDtoConf provides a newer format.
+         * @see getDtoConf
+         */
+        this.getApiSelection = () => convertDtoProductConfToV1(this._internal.getDtoConf(CfgProdConfParts.NoExtra), true);
+        /**
+         * Applies the configuration (selections) in the passed object onto the product recursively
+         * including product configuration, optional products and additional products.
+         * @param doValidate Makes a server side validation call. These are necessary to ensure that
+         *                   the right models are loaded.
+         * @deprecated setDtoConf uses a newer format.
+         */
+        this.setApiSelection = (configuration, doValidate = true) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(configuration, doValidate); });
+        /**
+         * A newer alternative version of getApiSelection. This returns the configuration (selections)
+         * on the product, recursively including product configuration, optional products and additional
+         * products.
+         * This version has the following advantages over getApiSelection:
+         * - The format is clearer, designed to be readable
+         * - Makes less assumptions about the structure in the Product being unchanging over time. In
+         *   particular, the Feature codes are included in the data, so that changes to what Features
+         *   are used in a Product is less likely to lead to unexpected results.
+         * - You can request ExtendedData, ProductParams and/or SyncGroupState to be included in the
+         *   result. This extra data is ignored when passed back into the API, but it can be very useful
+         *   for external applications.
+         * The other version (getApiSelection) has the advantage of using a format directly compatible with the API:s.
+         * @param include   Includes extra data which is not an actual part of the configuration
          */
-        this.getApiSelection = () => convertDtoConfProdToV1(this._internal.getDtoConf(false, false), true);
-        this.getDtoConf = (includeExtendedData = false, includeProductParams = false) => this._internal.getDtoConf(includeExtendedData, includeProductParams);
-        this.setDtoConf = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConf(s, doValidate); });
-        this.setApiSelection = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(s, doValidate); });
+        this.getDtoConf = (include = CfgProdConfParts.NoExtra) => this._internal.getDtoConf(include);
+        /**
+         * A newer alternative version of setApiSelection.
+         * @param doValidate Makes a server side validation call. These are necessary to ensure that
+         *                   the right models are loaded.
+         */
+        this.setDtoConf = (configuration, doValidate = true) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConf(configuration, doValidate); });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
         this.stopAllListenForChange = () => this._internal.changeObservable.stopAllListen();
@@ -662,9 +851,9 @@ export class CfgProduct {
         this.stopListenForLoading = (l) => this._internal.loadingObservable.stopListen(l);
         this.stopAllListenForLoading = () => this._internal.loadingObservable.stopAllListen();
     }
-    static make(productLoader, prodParams, settings) {
+    static make(productLoader, prodParams, settings, initialProductConfiguration) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._makeNewRefFrom(yield _CfgProductInternal.make(productLoader, undefined, prodParams, completeSettings(settings), false, new AggregatedLoadingObservable(), undefined, undefined, undefined));
+            return this._makeNewRefFrom(yield _CfgProductInternal.make(productLoader, undefined, prodParams, completeSettings(settings), false, new AggregatedLoadingObservable(), undefined, undefined, undefined, initialProductConfiguration));
         });
     }
     /**
@@ -690,6 +879,12 @@ export class CfgProduct {
     get refKey() {
         return this._internal.refKey;
     }
+    get notes() {
+        return this._internal.notes;
+    }
+    get miscFiles() {
+        return this._internal.miscFiles;
+    }
     get prodParams() {
         return this._internal.prodParams;
     }
@@ -727,12 +922,27 @@ export class CfgProduct {
     /**
      * Please note that this relates to the visibility in the Configuration tree.
      * It does not affect the visibility of anything in the 3D view at all.
-     * Visibility is affects the Configuration for this Product, but any Additional Products
+     * Visibility affects the Configuration for this Product, but any Additional Products
      * will not be affected.
      */
     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/CfgReferencePathHelper.d.ts

@@ -1,4 +1,4 @@
-import { DtoCatalogueParamsWithLang, DtoProductParamsWithLang } from "./CatalogueAPI";
+import { DtoCatalogueParamsWithCidAndLang, DtoProductParamsWithCidAndLang } from "./CatalogueAPI";
 /**
  * These methods aims to provide a default suggested way of building
  * URLs to Products and Catalogues. By using consistent URL:s copy-paste
@@ -14,7 +14,7 @@ export declare class CfgReferencePathHelper {
      * @param catParams What catalogue to generate URL for.
      * @returns An URL to a catalogue
      */
-    static getCataloguePath: (browsingRootUrl: string, catParams: DtoCatalogueParamsWithLang) => string;
+    static getCataloguePath: (browsingRootUrl: string, catParams: DtoCatalogueParamsWithCidAndLang) => string;
     /**
      * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
      * @param browsingRootUrl The URL where Stage browsing begins
@@ -22,6 +22,6 @@ export declare class CfgReferencePathHelper {
      * @param separator Optional, defaults to "product", but can be changed to indicate another function.
      * @returns An URL to a product
      */
-    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithLang, separator?: string) => string;
+    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithCidAndLang, separator?: string) => string;
 }
 //# sourceMappingURL=CfgReferencePathHelper.d.ts.map

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./CatalogueAPI.js";
 export * from "./CfgProduct.js";
 export * from "./CfgReferencePathHelper.js";
-export * from "./ConfigurationConverter.js";
 export * from "./io/index.js";
 export * from "./material/CfgMaterialMapping.js";
 export * from "./material/CfgMtrlApplication.js";
@@ -20,5 +19,6 @@ export * from "./tasks/formats.js";
 export * from "./tasks/TaskHandler.js";
 export * from "./utilitiesCatalogueData.js";
 export * from "./utilitiesCataloguePermission.js";
+export * from "./utilitiesConfiguration.js";
 export * from "./utilitiesNumericValues.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,6 @@
 export * from "./CatalogueAPI.js";
 export * from "./CfgProduct.js";
 export * from "./CfgReferencePathHelper.js";
-export * from "./ConfigurationConverter.js";
 export * from "./io/index.js";
 export * from "./material/CfgMaterialMapping.js";
 export * from "./material/CfgMtrlApplication.js";
@@ -20,4 +19,5 @@ export * from "./tasks/formats.js";
 export * from "./tasks/TaskHandler.js";
 export * from "./utilitiesCatalogueData.js";
 export * from "./utilitiesCataloguePermission.js";
+export * from "./utilitiesConfiguration.js";
 export * from "./utilitiesNumericValues.js";