@configura/web-api 2.0.0-alpha.20 → 2.0.0-alpha.22

package/dist/CfgProduct.js

@@ -9,7 +9,8 @@ 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 { convertDtoProductConfToV1 } from "./ConfigurationConverter.js";
+import { convertDtoProductConfToV1, isAdditionalProductConfiguration, isProductConf, } from "./ConfigurationConverter.js";
+import { CfgProdConfParts } from "./index.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
 import { CfgProductConfiguration } from "./productConfiguration/CfgProductConfiguration.js";
 import { collectAdditionalProductRefs } from "./productConfiguration/utilitiesProductConfiguration.js";
@@ -52,7 +53,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, rawFeatures, 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,6 +67,7 @@ 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 = () => {
@@ -103,7 +105,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);
@@ -150,18 +152,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;
@@ -175,15 +185,25 @@ export class _CfgProductInternal {
             return conf;
         };
         this.setDtoConf = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
+            // 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(convertDtoProductConfToV1(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.
@@ -201,18 +221,32 @@ export class _CfgProductInternal {
                 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;
@@ -265,7 +299,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;
                 }
             }
@@ -351,7 +385,10 @@ export class _CfgProductInternal {
                 if (this._destroyed) {
                     return false;
                 }
-                const { productData, rootFeatureRefs, features } = response;
+                const { productData, rootFeatureRefs, features, notes } = response;
+                if (notes !== undefined) {
+                    this.addNotes(notes.values());
+                }
                 const pricesUpdated = !comparePricesObjects(this.prices, productData.partsData.prices);
                 this._rawProductData = productData;
                 configuration._internal.addRawFeatures(features, true);
@@ -363,7 +400,7 @@ export class _CfgProductInternal {
                     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;
                 }
@@ -381,7 +418,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 || []),
@@ -423,10 +460,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) {
@@ -445,6 +489,9 @@ export class _CfgProductInternal {
         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 = _additionalProductRef !== undefined;
+        if (notes !== undefined) {
+            this.addNotes(notes);
+        }
         this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, rawFeatures, apiSelection, this, this.root);
     }
     get selected() {
@@ -462,7 +509,7 @@ export class _CfgProductInternal {
                 var _a;
                 const p = new _CfgProductInternal(() => {
                     initSuccess(p);
-                }, initFail, this._productLoaderRaw, this.prodParams, this.settings, this.optional, this.selected, this._configuration.rootFeatureRefs, this._configuration.rawFeatures, 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());
+                }, 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)));
@@ -481,6 +528,41 @@ export class _CfgProductInternal {
             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));
@@ -559,26 +641,29 @@ 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;
             }
-            // Vitally important that this happens before the call to reset. An optional
-            // additional product is always deselected at start, so this way the reset won't cause
-            // infinite loops
-            this._selected = v;
-            if (!v) {
-                yield this.reset();
-            }
-            if (v) {
-                const syncGroupHandler = this.syncGroupHandler;
-                if (syncGroupHandler !== undefined) {
-                    yield syncGroupHandler.init(this.root, wrapWithCache(this._productLoaderRaw));
+            // 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);
@@ -633,18 +718,43 @@ 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: rawFeatures, 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(() => {
@@ -652,12 +762,16 @@ prodParams, settings, optional, loadingObservable, parent, root, additionalProdu
                 // 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, rawFeatures, uuid, unit, productData, (_a = productData.partsData.selOptions) !== null && _a !== void 0 ? _a : [], 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);
+        yield product._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad, initialProductConfigurationV1);
         product._initialClone = yield product.clone();
-        if (syncGroupHandler !== undefined) {
-            // As syncGroupHandler is only set for root product we know that we will init with root
+        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;
@@ -682,7 +796,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
@@ -705,7 +819,7 @@ export class CfgProduct {
          * @deprecated getDtoConf provides a newer format.
          * @see getDtoConf
          */
-        this.getApiSelection = () => convertDtoProductConfToV1(this._internal.getDtoConf(false, false), true);
+        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.
@@ -723,16 +837,13 @@ export class CfgProduct {
          * - 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 and/or ProductParams 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.
+         * - 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 includeExtendedData  Includes extra data which is not an actual part of the configuration,
-         *                             i.e. units and groupCodes
-         * @param includeProductParams Includes what Product this was generated for, and the same for any
-         *                             Additional Products.
+         * @param include   Includes extra data which is not an actual part of the configuration
          */
-        this.getDtoConf = (includeExtendedData = false, includeProductParams = false) => this._internal.getDtoConf(includeExtendedData, includeProductParams);
+        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
@@ -746,9 +857,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));
         });
     }
     /**
@@ -774,6 +885,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;
     }
@@ -811,7 +928,7 @@ 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() {

package/dist/ConfigurationConverter.d.ts

@@ -1,4 +1,8 @@
 import { DtoAdditionalProductConf, DtoAdditionalProductConfiguration, DtoFeatureConf, DtoProductConf, DtoSelectedOption } from "./CatalogueAPI.js";
+/** Is the newer version of product configuration */
+export declare const isProductConf: (value: DtoAdditionalProductConfiguration | DtoProductConf) => value is DtoAdditionalProductConf;
+/** Is the older version of product configuration */
+export declare const isAdditionalProductConfiguration: (value: DtoAdditionalProductConfiguration | DtoProductConf) => value is DtoAdditionalProductConfiguration;
 export declare const isDtoProductConfAdditional: (value: DtoProductConf) => value is DtoAdditionalProductConf;
 export declare const convertDtoProductConfToV1: (conf: DtoProductConf, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
 export declare const convertDtoFeatureConfsToSelOptions: (features: DtoFeatureConf[], silenceWarnings?: boolean) => DtoSelectedOption[];

package/dist/ConfigurationConverter.js

@@ -1,3 +1,7 @@
+/** Is the newer version of product configuration */
+export const isProductConf = (value) => !("selOptions" in value);
+/** Is the older version of product configuration */
+export const isAdditionalProductConfiguration = (value) => "selOptions" in value;
 export const isDtoProductConfAdditional = (value) => "refKey" in value;
 // As this has potential to flood the terminal we only inform once
 let hasInformedAboutProdParams = false;
@@ -90,6 +94,11 @@ for (const [long, short] of [
     ["numericValue", "n"],
     ["groupCode", "g"],
     ["unit", "u"],
+    ["syncGroupState", "sgs"],
+    ["selectOne", "so"],
+    ["selectMany", "sm"],
+    ["syncCode", "sc"],
+    ["optionCode", "oc"],
 ]) {
     shortToLong.set(short, long);
     longToShort.set(long, short);

package/dist/io/CfgHistoryManager.js

@@ -59,12 +59,6 @@ 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/CfgHistoryToProdConfConnector.d.ts

@@ -7,12 +7,16 @@ import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConne
 export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector<CfgHistoryManagerSendData<CfgProdConfMessage>> {
     private readonly _mode;
     private readonly _qsKey;
+    private static getInitialProdConf;
+    static make(manager: CfgHistoryManager, mode: HistoryMode, qsKey?: string): {
+        instance: CfgHistoryToProdConfConnector;
+        initial: DtoProductConf | undefined;
+    };
     /**
      * @param _mode
      * @param _qsKey The Query String key for product configuration.
      */
-    constructor(manager: CfgHistoryManager, _mode: HistoryMode, _qsKey?: string);
-    protected getInitialProdConf(): DtoProductConf | undefined;
+    private constructor();
     protected makeSendData(conf: DtoProductConf, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
 }
 //# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -1,7 +1,7 @@
 import { augmentErrorMessage } from "@configura/web-utilities";
 import { compactStringToDtoProductConf, dtoProductConfigurationToCompactString, } from "../ConfigurationConverter.js";
 import { CfgHistoryManager } from "./CfgHistoryManager.js";
-import { CfgIOProdConfConnector, CfgProdConfMessageVersions, getHighestVersionProdConfMessage, isCfgProdConfMessageV2, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
+import { CfgIOProdConfConnector, CfgProdConfMessageVersions, CfgProdConfParts, getHighestVersionProdConfMessage, isCfgProdConfMessageV2, STAGE_PROD_CONF_MESSAGE_KEY, } from "./CfgIOProdConfConnector.js";
 /**
  * Instantiating this will make the browser history (and URL) update with the product configuration.
  */
@@ -10,12 +10,12 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
      * @param _mode
      * @param _qsKey The Query String key for product configuration.
      */
-    constructor(manager, _mode, _qsKey = STAGE_PROD_CONF_MESSAGE_KEY) {
-        super(manager, false, false);
+    constructor(manager, _mode, _qsKey) {
+        super(manager, CfgProdConfParts.SyncGroupState);
         this._mode = _mode;
         this._qsKey = _qsKey;
     }
-    getInitialProdConf() {
+    static getInitialProdConf(qsKey) {
         // First try to use the state, if that doesn't work use the query string
         const initialMessage = CfgHistoryManager.getMessageFromCurrentHistoryState(STAGE_PROD_CONF_MESSAGE_KEY);
         if (initialMessage !== undefined) {
@@ -25,7 +25,7 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
             }
         }
         try {
-            const s = CfgHistoryManager.currentQsKeyValues().get(this._qsKey);
+            const s = CfgHistoryManager.currentQsKeyValues().get(qsKey);
             if (s === undefined) {
                 return undefined;
             }
@@ -35,12 +35,15 @@ export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
             throw augmentErrorMessage(err, "Failed read configuration from query string");
         }
     }
+    static make(manager, mode, qsKey = STAGE_PROD_CONF_MESSAGE_KEY) {
+        const initial = this.getInitialProdConf(qsKey);
+        const instance = new CfgHistoryToProdConfConnector(manager, mode, qsKey);
+        return { instance, initial };
+    }
     makeSendData(conf, initial) {
         return {
             message: CfgIOProdConfConnector.makeMessage(conf, initial, CfgProdConfMessageVersions.V2dot0),
-            qsKeyValues: new Map([
-                [STAGE_PROD_CONF_MESSAGE_KEY, dtoProductConfigurationToCompactString(conf)],
-            ]),
+            qsKeyValues: new Map([[this._qsKey, dtoProductConfigurationToCompactString(conf)]]),
             mode: this._mode,
         };
     }

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -22,6 +22,17 @@ export declare enum CfgProdConfMessageVersions {
     V1dot0 = 1,
     V2dot0 = 2
 }
+/**
+ * @param ExtendedData   Includes extra data, i.e. units and groupCodes
+ * @param ProductParams  Includes what Product this was generated for, and the same for any Additional Products.
+ * @param SyncGroupState Includes the current sync group state
+ */
+export declare enum CfgProdConfParts {
+    NoExtra = 0,
+    ExtendedData = 1,
+    ProdParams = 2,
+    SyncGroupState = 4
+}
 export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
 declare type ProdConfMessageCallback = (message: CfgProdConfMessage) => Promise<void>;
 declare type ProdConfCallback = (conf: DtoProductConf) => Promise<void>;
@@ -30,28 +41,25 @@ declare type ProdConfCallback = (conf: DtoProductConf) => Promise<void>;
  */
 export declare abstract class CfgIOProdConfConnector<S> implements CfgIOWarningSupplier {
     protected readonly _ioManager: CfgIOManager<S>;
-    private readonly _includeExtendedDataInSend;
-    private readonly _includeProdParamsInSend;
+    private readonly _includeInSend;
     protected _product: CfgProduct | undefined;
     private _stopListenToMessage;
     private _stopListenToProdConf;
-    constructor(_ioManager: CfgIOManager<S>, _includeExtendedDataInSend: boolean, // Only for v2.0
-    _includeProdParamsInSend: boolean);
+    constructor(_ioManager: CfgIOManager<S>, _includeInSend: CfgProdConfParts);
     destroy(): void;
     getWarnings(): string[];
     setProduct: (product: CfgProduct | undefined) => Promise<void>;
     private _send;
-    protected getInitialProdConf(): DtoProductConf | undefined;
     protected abstract makeSendData(conf: DtoProductConf, initial: boolean): S;
-    static makeMessage(conf: DtoProductConf, initial: boolean, sendVersions: CfgProdConfMessageVersions): CfgProdConfMessage;
-    static makeMessageListener(callback: ProdConfMessageCallback): (message: unknown) => Promise<void>;
+    static makeMessage: (conf: DtoProductConf, initial: boolean, sendVersions: CfgProdConfMessageVersions) => CfgProdConfMessage;
+    static makeMessageListener: (callback: ProdConfMessageCallback) => (message: unknown) => Promise<void>;
     /**
      * Register the callback to listen for Product Configuration messages
      * @returns A function which when called will cancel listening
      */
     static listenForMessage<S>(callback: ProdConfMessageCallback, ioManager: CfgIOManager<S>): () => void;
-    static makeProdConfListener(callback: ProdConfCallback, includeExtendedDataInSend: boolean, includeProdParamsInSend: boolean): (n: CfgProductChangeNotification) => void;
-    static listenForProdConf(product: CfgProduct, callback: ProdConfCallback, includeExtendedDataInSend: boolean, includeProdParamsInSend: boolean): () => void;
+    static makeProdConfListener: (callback: ProdConfCallback, includeInSend: CfgProdConfParts) => (n: CfgProductChangeNotification) => void;
+    static listenForProdConf(product: CfgProduct, callback: ProdConfCallback, includeInSend: CfgProdConfParts): () => void;
 }
 export {};
 //# sourceMappingURL=CfgIOProdConfConnector.d.ts.map