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

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -17,15 +17,15 @@ export declare type StretchMap = Map<string, {
  * modified. CfgProductConfiguration is the class that should be used and interacted with.
  */
 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.
+    static _makeUninitialized(rootFeatureRefs: DtoFeatureRef[], rawFeatures: DtoFeature[], // Flat packed. All the features that can currently appear anyplace in the selection tree.
     parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): _CfgProductConfigurationInternal;
     private constructor();
     readonly key = "~";
     private _rootFeatureRefs;
+    readonly accumulatedRawFeatures: DtoFeature[];
     private _features;
     readonly stretchReferenceLengthsByMeasureParamCode: StretchMap;
     readonly changeObservable: Observable<ProductConfigurationChangeNotification>;
@@ -51,13 +51,22 @@ export declare class _CfgProductConfigurationInternal {
     tryMatchSelection: (other: _CfgProductConfigurationInternal, descriptionMatch: boolean | undefined, validate: boolean) => Promise<boolean>;
     /** Only selected features. */
     _getFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
+    /**
+     * Extends the list of loaded potentially used features. Will warn for but ignore duplicates.
+     * Returns true if a change happened.
+     */
+    addRawFeatures: (rawFeatures: DtoFeature[], warnForDuplicates: boolean) => boolean;
     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;
+    /**
+     * Populates _features based on the passed @param rootFeatureRefs .
+     * @return true if a change happened.
+     */
+    populateFeatures: (rootFeatureRefs: DtoFeatureRef[]) => boolean;
     setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit) => Promise<boolean>;
 }
 export declare class CfgProductConfiguration {
@@ -67,7 +76,7 @@ export declare class CfgProductConfiguration {
      * CfgProductConfiguration, but is not properly initialized until the initDone-callback
      * has been called.
      */
-    static make(initSuccess: (c: CfgProductConfiguration) => void, initFail: (error: Error) => void, rootFeatureRefs: DtoFeatureRef[], allRawFeatures: DtoFeature[], // Flat packed. All the features that can appear anyplace in the selection tree.
+    static make(initSuccess: (c: CfgProductConfiguration) => void, initFail: (error: Error) => void, rootFeatureRefs: DtoFeatureRef[], rawFeatures: DtoFeature[], // Flat packed. All the features that can currently appear anyplace in the selection tree.
     apiSelection: DtoSelectedOption[], parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgProductConfiguration;
     /**
      * Makes an object wrapping the passed object. This is not a clone method, it is a method to
@@ -87,11 +96,11 @@ export declare class CfgProductConfiguration {
     get rootProduct(): CfgProduct;
     get key(): string;
     /**
-     * Every (unprocessed) feature which might be used in this product. This is constant for a
-     * product load. What features are actually used is controlled by rootFeatureRefs and what
+     * Every (unprocessed) feature that is currently loaded for this product. This can be extended
+     * by validation calls. What features are actually used is controlled by rootFeatureRefs and what
      * options are selected.
      */
-    get allRawFeatures(): DtoFeature[];
+    get rawFeatures(): DtoFeature[];
     /** What features are used in the root of this. This can change with new validate calls. */
     get rootFeatureRefs(): DtoFeatureRef[];
     /** The root features at the root of the selection tree. */

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -19,14 +19,13 @@ import { syncCfgFeatures } from "./utilitiesProductConfiguration.js";
  * modified. CfgProductConfiguration is the class that should be used and interacted with.
  */
 export class _CfgProductConfigurationInternal {
-    constructor(allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
-    parentProduct, rootProduct, _initialRootFeatureRefs) {
-        this.allRawFeatures = allRawFeatures;
+    constructor(rawFeatures, parentProduct, rootProduct, _initialRootFeatureRefs) {
         this.parentProduct = parentProduct;
         this.rootProduct = rootProduct;
         this._initialRootFeatureRefs = _initialRootFeatureRefs;
         this.key = "~";
         this._rootFeatureRefs = [];
+        this.accumulatedRawFeatures = []; // Flat packed. May be extended in validate calls.
         this._features = [];
         this.changeObservable = new Observable();
         this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
@@ -114,11 +113,39 @@ export class _CfgProductConfigurationInternal {
             agg.push(...feature._internal._getFeaturesWithCode(code));
             return agg;
         }, []);
+        /**
+         * Extends the list of loaded potentially used features. Will warn for but ignore duplicates.
+         * Returns true if a change happened.
+         */
+        this.addRawFeatures = (rawFeatures, warnForDuplicates) => {
+            let change = false;
+            const accumulatedRawFeatures = this.accumulatedRawFeatures;
+            for (const rawFeature of rawFeatures) {
+                const code = rawFeature.code;
+                if (accumulatedRawFeatures.find((f) => code === f.code)) {
+                    if (warnForDuplicates) {
+                        console.warn(`Feature ${code} was already loaded. Will ignore it.`);
+                    }
+                    continue;
+                }
+                accumulatedRawFeatures.push(rawFeature);
+                change = true;
+            }
+            return change;
+        };
         this._hasRootFeaturesChanged = false;
+        /**
+         * Populates _features based on the passed @param rootFeatureRefs .
+         * @return true if a change happened.
+         */
         this.populateFeatures = (rootFeatureRefs) => {
+            if (compareArrays(this._rootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code, true)) {
+                return false;
+            }
             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._features = syncCfgFeatures(rootFeatureRefs, this._features, this.accumulatedRawFeatures, this, this, this.parentProduct, this.rootProduct);
+            return true;
         };
         this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => __awaiter(this, void 0, void 0, function* () {
             if (measureParamCode === "") {
@@ -163,6 +190,8 @@ export class _CfgProductConfigurationInternal {
             console.log(`Use "window['${dbgName}']" or window.conf to access conf.`);
         }
         /* eslint-enable */
+        this.addRawFeatures(rawFeatures, true);
+        this.populateFeatures(_initialRootFeatureRefs);
         /**
          * Although the measurement-datas are also passed in validate-calls they are only used at
          * initial product creation. The data is assumed to always be the same for a product, so
@@ -199,11 +228,9 @@ export class _CfgProductConfigurationInternal {
         }
         this.stretchReferenceLengthsByMeasureParamCode = stretchReferenceLengthsByMeasureParamCode;
     }
-    static _makeUninitialized(rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
+    static _makeUninitialized(rootFeatureRefs, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
     parentProduct, rootProduct) {
-        const configuration = new this(allRawFeatures, parentProduct, rootProduct, rootFeatureRefs);
-        configuration.populateFeatures(rootFeatureRefs);
-        return configuration;
+        return new this(rawFeatures, parentProduct, rootProduct, rootFeatureRefs);
     }
     get rootFeatureRefs() {
         return this._rootFeatureRefs;
@@ -265,9 +292,9 @@ export class CfgProductConfiguration {
      * CfgProductConfiguration, but is not properly initialized until the initDone-callback
      * has been called.
      */
-    static make(initSuccess, initFail, rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
+    static make(initSuccess, initFail, rootFeatureRefs, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
     apiSelection, parentProduct, rootProduct) {
-        const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, allRawFeatures, parentProduct, rootProduct);
+        const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, rawFeatures, parentProduct, rootProduct);
         const external = new this(internal);
         // Note the async-callback at the end of the following line. The call is async.
         internal
@@ -295,12 +322,12 @@ export class CfgProductConfiguration {
         return this._internal.key;
     }
     /**
-     * Every (unprocessed) feature which might be used in this product. This is constant for a
-     * product load. What features are actually used is controlled by rootFeatureRefs and what
+     * Every (unprocessed) feature that is currently loaded for this product. This can be extended
+     * by validation calls. What features are actually used is controlled by rootFeatureRefs and what
      * options are selected.
      */
-    get allRawFeatures() {
-        return this._internal.allRawFeatures;
+    get rawFeatures() {
+        return this._internal.accumulatedRawFeatures;
     }
     /** What features are used in the root of this. This can change with new validate calls. */
     get rootFeatureRefs() {

package/dist/productConfiguration/filters.d.ts

@@ -1,6 +1,6 @@
 import { Filters, Matches } from "@configura/web-utilities";
-import { DtoCatalogueParamsWithoutCid, DtoLevel, DtoProductRef } from "../CatalogueAPI.js";
-export declare function applyCatalogueFilters<T extends DtoCatalogueParamsWithoutCid>(filters: Filters<DtoCatalogueParamsWithoutCid>, catalogues: T[]): [Matches<DtoCatalogueParamsWithoutCid>, T[]];
+import { DtoCatalogueParams, DtoLevel, DtoProductRef } from "../CatalogueAPI.js";
+export declare function applyCatalogueFilters<T extends DtoCatalogueParams>(filters: Filters<DtoCatalogueParams>, catalogues: T[]): [Matches<DtoCatalogueParams>, T[]];
 export interface ProductRefParams {
     partNr: string;
 }

package/dist/productConfiguration/productParamsGenerator.d.ts

@@ -1,16 +1,16 @@
 import { Filters } from "@configura/web-utilities";
-import { CatalogueAPI, DtoApplicationAreasResponse, DtoCatalogueParams, DtoCatalogueParamsWithLang } from "../CatalogueAPI.js";
+import { CatalogueAPI, DtoApplicationAreasResponse, DtoCatalogueParamsWithCid, DtoCatalogueParamsWithCidAndLang } from "../CatalogueAPI.js";
 import { CfgProduct, CfgProductSettings } from "../CfgProduct.js";
 import { ProductRefParams } from "./filters.js";
 export interface GeneratedProductConfiguration {
     applicationAreasResponse: DtoApplicationAreasResponse;
     catalogueCount: number;
     catalogueIndex: number;
-    catalogueParams: DtoCatalogueParamsWithLang;
+    catalogueParams: DtoCatalogueParamsWithCidAndLang;
     getProductDuration: number;
     product: CfgProduct;
     productCount: number;
     productIndex: number;
 }
-export declare function generateProductConfigurations(api: CatalogueAPI, lang: string, catalogues: DtoCatalogueParams[], filters: Filters<ProductRefParams>, settings?: Partial<CfgProductSettings>): AsyncIterableIterator<GeneratedProductConfiguration | Error>;
+export declare function generateProductConfigurations(api: CatalogueAPI, lang: string, catalogues: DtoCatalogueParamsWithCid[], filters: Filters<ProductRefParams>, settings?: Partial<CfgProductSettings>): AsyncIterableIterator<GeneratedProductConfiguration | Error>;
 //# sourceMappingURL=productParamsGenerator.d.ts.map

package/dist/productConfiguration/utilitiesProductConfiguration.d.ts

@@ -8,7 +8,7 @@ import { CfgProductConfiguration, _CfgProductConfigurationInternal } from "./Cfg
  * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
  * currentFeatures if they can be found, otherwise makes new.
  */
-export declare function syncCfgFeatures(newFeatureRefs: DtoFeatureRef[], currentFeatures: CfgFeature[], allRawFeatures: DtoFeature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
+export declare function syncCfgFeatures(newFeatureRefs: DtoFeatureRef[], currentFeatures: CfgFeature[], rawFeatures: DtoFeature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
 export declare function getMtrlPreview(mtrlApplications: CfgMtrlApplication[] | undefined): string | undefined;
 /**
  * Recursively find all additional product references given a product configuration.

package/dist/productConfiguration/utilitiesProductConfiguration.js

@@ -6,11 +6,11 @@ import { CfgProductConfiguration, } from "./CfgProductConfiguration.js";
  * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
  * currentFeatures if they can be found, otherwise makes new.
  */
-export function syncCfgFeatures(newFeatureRefs, currentFeatures, allRawFeatures, parent, parentConfiguration, parentProduct, rootProduct) {
+export function syncCfgFeatures(newFeatureRefs, currentFeatures, rawFeatures, parent, parentConfiguration, parentProduct, rootProduct) {
     const usedRawFeatures = newFeatureRefs
         .map((r) => r.code)
         .map((c) => {
-        const rawFeature = allRawFeatures.find((f) => c === f.code);
+        const rawFeature = rawFeatures.find((f) => c === f.code);
         if (rawFeature === undefined) {
             throw new Error(`Feature not found. Requested feature code: "${c}".`);
         }
@@ -38,12 +38,19 @@ export function syncCfgFeatures(newFeatureRefs, currentFeatures, allRawFeatures,
         // products with similar feature-options tree and trying
         // to retain made selections
         const key = fDescription + (fDescription === "" || hasDuplicateDescription ? fCode : "");
-        const existingFeature = currentFeatures.find((cfgF) => cfgF.code === fCode && cfgF.key === key);
+        const existingFeature = currentFeatures.find((cfgF) => cfgF.code === fCode);
         if (existingFeature !== undefined) {
+            if (hasDuplicateDescription) {
+                // HasDuplicateDescription could mean the key need to be more specific compared
+                // to the one we already have, so then we set it. An old duplicate description
+                // key will cause no harm as it is guaranteed to be at least as specific as this.
+                // Not changing the key will make React not rerender, so we don't change.
+                existingFeature._internal.key = key;
+            }
             newFeatures.push(existingFeature);
             continue;
         }
-        newFeatures.push(CfgFeature.make(f, allRawFeatures, key, parent, parentConfiguration, parentProduct, rootProduct));
+        newFeatures.push(CfgFeature.make(f, rawFeatures, key, parent, parentConfiguration, parentProduct, rootProduct));
     }
     return newFeatures;
 }

package/dist/productLoader.d.ts

@@ -1,7 +1,7 @@
-import { DtoProductParamsWithLang, DtoValidateRequest } from "./CatalogueAPI.js";
+import { DtoProductParamsWithCidAndLang, DtoValidateRequest } from "./CatalogueAPI.js";
 import { CfgProductResponse, CfgValidateResponse } from "./utilitiesCatalogueData.js";
-export declare type GetProduct = (params: DtoProductParamsWithLang) => Promise<CfgProductResponse>;
-export declare type PostValidate = (params: DtoProductParamsWithLang, body: DtoValidateRequest) => Promise<CfgValidateResponse>;
+export declare type GetProduct = (params: DtoProductParamsWithCidAndLang) => Promise<CfgProductResponse>;
+export declare type PostValidate = (params: DtoProductParamsWithCidAndLang, body: DtoValidateRequest) => Promise<CfgValidateResponse>;
 export declare type ProductLoader = {
     getProduct: GetProduct;
     postValidate: PostValidate;

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -24,7 +24,10 @@ export declare class SyncGroupsHandler {
     clone(): SyncGroupsHandler;
     get verboseLogging(): boolean;
     set verboseLogging(v: boolean);
-    /** Used to initially apply the sync state onto a new product so that it is "in sync". */
+    /**
+     * Used to initially apply the sync state onto a new product so that it is "in sync"
+     * and to reapply the sync state when an optional additional product is selected.
+     */
     init(product: _CfgProductInternal, productLoader: ProductLoader): Promise<void>;
     /**
      * Used when an Option is selected or deselected to apply all consequences of the sync groups.

package/dist/syncGroups/SyncGroupsHandler.js

@@ -123,7 +123,8 @@ import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
  * C) The SyncState has an option code for this SyncGroup.
  * D) The option code in the SyncState for the SyncGroup is not the Option selected.
  * E) The Feature has an Option with the right option code.
- * F) The Feature has not previously been affected in this transaction.
+ * F) The Feature has not previously been affected in this transaction, unless it was affected
+ *    at Feature initialization.
  *
  * ...for SelectMany (done for every Option):
  * C) The SyncState has a value (on or off) for this SyncGroup and option code.
@@ -275,7 +276,10 @@ export class SyncGroupsHandler {
     set verboseLogging(v) {
         this._syncState.verboseLogging = v;
     }
-    /** Used to initially apply the sync state onto a new product so that it is "in sync". */
+    /**
+     * Used to initially apply the sync state onto a new product so that it is "in sync"
+     * and to reapply the sync state when an optional additional product is selected.
+     */
     init(product, productLoader) {
         return __awaiter(this, void 0, void 0, function* () {
             const transaction = yield this.newTransaction(product, productLoader, true);

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -13,6 +13,12 @@ import { SelectionType, } from "../productConfiguration/CfgFeature.js";
 import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
 import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
 import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
+var AffectedLevel;
+(function (AffectedLevel) {
+    AffectedLevel[AffectedLevel["None"] = 0] = "None";
+    AffectedLevel[AffectedLevel["Initialized"] = 1] = "Initialized";
+    AffectedLevel[AffectedLevel["Set"] = 2] = "Set";
+})(AffectedLevel || (AffectedLevel = {}));
 /**
  * The Transaction is a transient object used to track all the changes made to the supplied
  * SyncGroupState as a result of a (normally) single initial event, like when opening a product
@@ -39,7 +45,7 @@ import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
 export class SyncGroupsTransaction {
     constructor(syncState, updateMode, productLoader, original, target, initial) {
         this._closed = false;
-        this.affectedSelectOneFeatures = new Set();
+        this.affectedSelectOneFeatures = new Map();
         this.affectedSelectManyOptions = new Set();
         this.affectedSelectOneSyncGroups = new Set();
         this.affectedSelectManySyncGroupsAndOptions = new Map();
@@ -104,7 +110,7 @@ export class SyncGroupsTransaction {
                 change = true;
                 switch (feature.selectionType) {
                     case SelectionType.SelectOne:
-                        this.affectedSelectOneFeatures.add(feature);
+                        this.affectedSelectOneFeatures.set(feature, AffectedLevel.Set);
                         break;
                     case SelectionType.SelectMany:
                         this.affectedSelectManyOptions.add(option);
@@ -266,14 +272,19 @@ export class SyncGroupsTransaction {
         return __awaiter(this, void 0, void 0, function* () {
             const feature = featureWithInitial.target;
             const featureDidJustComeIntoScope = featureWithInitial.initial === undefined;
-            if (this.affectedSelectOneFeatures.has(feature)) {
-                // This feature has already changed selection once for this transaction. We expect
-                // this to happen very rarely, as the algorithm should settle the selection tree
-                // further and further out. Nevertheless, this safeguard is needed to avoid infinite
-                // looping if for example the server would return the same data over and over.
+            const hasBeenAffectedLevel = this.affectedSelectOneFeatures.get(feature);
+            const syncGroupHasBeenUpdated = this.affectedSelectOneSyncGroups.has(syncCode);
+            if (hasBeenAffectedLevel === AffectedLevel.Set ||
+                (!syncGroupHasBeenUpdated && hasBeenAffectedLevel === AffectedLevel.Initialized)) {
+                // A feature can change value for two reasons:
+                // 1. The feature did just come into scope and loads from the sync group to set its "defaults"
+                // 2. The sync group has updated with a new value
+                // The rule is that in one sync group transaction the feature value is allowed to be updated
+                // once or twice. Once for initialization and once for new sync group value. But they have to
+                // happen in the right order.
                 return "recurseDown";
             }
-            if (!featureDidJustComeIntoScope && !this.affectedSelectOneSyncGroups.has(syncCode)) {
+            if (!featureDidJustComeIntoScope && !syncGroupHasBeenUpdated) {
                 return "recurseDown";
             }
             const currentSyncGroupValue = this.syncState.getForSelectOne(syncCode);
@@ -295,7 +306,7 @@ export class SyncGroupsTransaction {
             // Do not recurse further as we will change the state and so what is selected now won't be
             // selected then.
             yield feature.selectOption(optionToSelect._internal, true, ProductConfigurationBubbleMode.ToRoot);
-            this.affectedSelectOneFeatures.add(feature);
+            this.affectedSelectOneFeatures.set(feature, syncGroupHasBeenUpdated ? AffectedLevel.Set : AffectedLevel.Initialized);
             productsToValidate.add(feature.parentProduct);
             return "stop";
         });
@@ -435,7 +446,7 @@ export class SyncGroupsTransaction {
             return change;
         });
     }
-    applySelectOneFeature(feature, activeSelectionForce, featureDidJustComeIntoScope) {
+    applySelectOneFeature(feature, userInitiated, featureDidJustComeIntoScope) {
         const selectionType = feature.selectionType;
         if (selectionType !== SelectionType.SelectOne) {
             throw new Error("can only be used for selectOne");
@@ -453,7 +464,7 @@ export class SyncGroupsTransaction {
             // Options with no default are never written
             return false;
         }
-        if (activeSelectionForce) {
+        if (userInitiated) {
             // To make re-apply happen, even if it actually does not update the sync group
             this.affectedSelectOneSyncGroups.add(syncCode);
         }
@@ -464,7 +475,7 @@ export class SyncGroupsTransaction {
         // can not be set to the current sync group value, then it will set in the opposite
         // direction. Like if the sync group was empty. To avoid bouncing back and forth we will
         // need to enforce that a sync group can only be updated once per transaction
-        if (!(activeSelectionForce ||
+        if (!(userInitiated ||
             currentSyncGroupOptionCode === undefined ||
             (featureDidJustComeIntoScope &&
                 feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
@@ -486,7 +497,7 @@ export class SyncGroupsTransaction {
         }
         return change;
     }
-    applySelectManyOption(option, activeSelectionForce) {
+    applySelectManyOption(option, userInitiated) {
         const feature = option.parent;
         if (feature.selectionType !== SelectionType.SelectMany) {
             throw new Error("can only be used for selectMany");
@@ -500,14 +511,14 @@ export class SyncGroupsTransaction {
         }
         const optionSelected = option.selected;
         const currentSyncGroupValue = this.syncState.getForSelectMany(syncCode, option.code);
-        if (activeSelectionForce) {
+        if (userInitiated) {
             // To make re-apply happen, even if it actually does not update the sync group
             this.addSyncGroupAffectedForSelectMany(syncCode, option);
         }
-        // We only initialize if the option is selected or we force.
-        // activeSelectionForce = active selection by the user.
-        if (!(currentSyncGroupValue === undefined && optionSelected) &&
-            !(activeSelectionForce && currentSyncGroupValue !== optionSelected)) {
+        // We only initialize if the option has not been initiated or if it is userInitiated.
+        // userInitiated = active selection by the user.
+        if (currentSyncGroupValue !== undefined &&
+            !(userInitiated && currentSyncGroupValue !== optionSelected)) {
             return false;
         }
         this.addSyncGroupAffectedForSelectMany(syncCode, option);
@@ -529,7 +540,9 @@ export class SyncGroupsTransaction {
 }
 function getAdditionalProducts(product) {
     const initial = product.initial;
-    return product.target.additionalProducts.map((childTarget) => {
+    return product.target.additionalProducts
+        .filter((p) => p.selected)
+        .map((childTarget) => {
         const refKey = childTarget.refKey;
         const childInitial = initial === null || initial === void 0 ? void 0 : initial.additionalProducts.find((p) => refKey === p.refKey);
         return {
@@ -558,8 +571,8 @@ function getOptions(feature) {
 }
 function pairFeatures(targets, initials) {
     return targets.map((childTarget) => {
-        const key = childTarget.key;
-        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => key === f.key);
+        const code = childTarget.code;
+        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => code === f.code);
         return {
             target: childTarget._internal,
             initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,

package/dist/tasks/TaskHandler.d.ts

@@ -1,5 +1,5 @@
 import { Observable, SingleArgCallback } from "@configura/web-utilities";
-import { CatalogueAPI, DtoAdditionalProductConfiguration, DtoExportStatus, DtoExportStatusStatus, DtoProductParamsWithLang, DtoRenderStatus, DtoRenderStatusStatus, DtoTargetCameraArgs } from "../CatalogueAPI.js";
+import { CatalogueAPI, DtoAdditionalProductConfiguration, DtoExportStatus, DtoExportStatusStatus, DtoProductParamsWithCidAndLang, DtoRenderStatus, DtoRenderStatusStatus, DtoTargetCameraArgs } from "../CatalogueAPI.js";
 import { CfgProduct } from "../CfgProduct.js";
 import { RenderOrExportFormat } from "./formats.js";
 export declare type TasksChangeNotification = {
@@ -51,7 +51,7 @@ export declare abstract class Task<F extends RenderOrExportFormat> {
     protected constructor(taskHandler: _TaskHandlerInternal, format: F, product: CfgProduct, getPreviewUrl: (() => Promise<string>) | undefined);
     protected abstract postInit(): Promise<DtoRenderStatus | DtoExportStatus>;
     protected abstract pollStatus(): Promise<DtoRenderStatus | DtoExportStatus>;
-    protected _productParams: DtoProductParamsWithLang;
+    protected _productParams: DtoProductParamsWithCidAndLang;
     protected _apiSelection: DtoAdditionalProductConfiguration;
     private _status;
     private _uuid;

package/dist/tests/testData/dummyProductForTest.d.ts

@@ -1,5 +1,5 @@
-import { DtoCatalogueParamsWithLang } from "../../CatalogueAPI.js";
+import { DtoCatalogueParamsWithCidAndLang } from "../../CatalogueAPI.js";
 import { CfgProduct } from "../../CfgProduct.js";
-export declare const dummyCatId: DtoCatalogueParamsWithLang;
+export declare const dummyCatId: DtoCatalogueParamsWithCidAndLang;
 export declare const getDummyCfgProduct: () => Promise<CfgProduct>;
 //# sourceMappingURL=dummyProductForTest.d.ts.map

package/dist/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.js

@@ -254,6 +254,7 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
                 uuid: "",
                 validated: true,
                 productData,
+                features: []
             };
             collect.pushNotification(`Validate ${params.enterprise} ${params.prdCat} ${params.prdCatVersion} ${params.priceList} ${params.vendor} ${params.partNumber}`);
             return validateResponse;

package/dist/tests/testData/testDataCachedGetProduct.js

@@ -173,6 +173,7 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
                 uuid: "",
                 validated: true,
                 productData,
+                features: []
             };
             return validateResponse;
         }),

package/dist/tests/testData/testDataCachedPostValidate.js

@@ -173,6 +173,7 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
                 uuid: "",
                 validated: true,
                 productData,
+                features: [],
             };
             validateCounter.count++;
             return validateResponse;

package/dist/tests/testData/testDataProductAggregatedPrice.js

@@ -176,6 +176,7 @@ export const cfgProductPriceTest = (testFunc, featureOption) => __awaiter(void 0
                 uuid: "",
                 validated: true,
                 productData,
+                features: [],
             };
             return validateResponse;
         }),

package/dist/tests/testData/testDataUpcharge.js

@@ -99,6 +99,7 @@ export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0
                 uuid: "",
                 validated: true,
                 productData,
+                features: [],
             };
             return validateResponse;
         }),

package/dist/utilitiesCatalogueData.d.ts

@@ -1,12 +1,12 @@
-import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithLang, DtoCatalogueParamsWithoutCid, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParams, DtoProductParamsWithLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
+import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithCid, DtoCatalogueParamsWithCidAndLang, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParamsWithCid, DtoProductParamsWithCidAndLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
 /**
  * Makes a string from the params which can be used as a key in for example React. Language is not respected.
  */
-export declare const makeCatalogueKey: (cat: DtoCatalogueParams) => string;
+export declare const makeCatalogueKey: (cat: DtoCatalogueParamsWithCid) => string;
 /**
  * Makes a string from the params which can be used as a key in for example React. Language is not respected.
  */
-export declare const makeProductKey: (prod: DtoProductParams) => string;
+export declare const makeProductKey: (prod: DtoProductParamsWithCid) => string;
 /**
  * Makes a string from selected options, can be used as a key for a selection.
  */
@@ -18,6 +18,11 @@ export declare type CfgProductData = Omit<Omit<DtoProductData, "models">, "parts
         selOptions: DtoSelectedOption[];
     };
 };
+/**
+ * Deep compare. Uses the JSON.stringify method for comparison
+ * @returns true if equal. Key and array order is respected.
+ */
+export declare function compareCfgProductData(pd1: CfgProductData, pd2: CfgProductData): boolean;
 export declare type CfgProductResponse = Omit<DtoProductResponse, "productData"> & {
     productData: CfgProductData;
 };
@@ -27,17 +32,17 @@ export declare type CfgValidateResponse = Omit<DtoValidateResponse, "productData
 };
 export declare function isModel(arg: unknown): arg is DtoModel;
 /** Replace empty strings with "-" for compatibility with the API. */
-export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParamsWithoutCid>(catId: T): T;
+export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParams>(catId: T): T;
 export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: DtoPrices | undefined): number | undefined;
 export declare function comparePricesObjects(prices1: DtoPrices | undefined, prices2: DtoPrices | undefined): boolean;
-export declare const decodeCatalogueParams: <T extends DtoCatalogueParamsWithoutCid>(params: T) => T;
-export declare const decodeProductParams: <T extends DtoProductParams>(params: T) => T;
-export declare function isSameCatalogueParams(left: DtoCatalogueParamsWithoutCid, right: DtoCatalogueParamsWithoutCid): boolean;
+export declare const decodeCatalogueParams: <T extends DtoCatalogueParams>(params: T) => T;
+export declare const decodeProductParams: <T extends DtoProductParamsWithCid>(params: T) => T;
+export declare function isSameCatalogueParams(left: DtoCatalogueParams, right: DtoCatalogueParams): boolean;
 export declare function isSameVector(left: DtoVector, right: DtoVector): boolean;
 export declare function isSameOrientation(left: DtoOrientation, right: DtoOrientation): boolean;
 export declare function isSameAnchor(left: DtoMeasureParam, right: DtoMeasureParam): boolean;
 export declare function isSameTransform(left: DtoTransform, right: DtoTransform): boolean;
 export declare function isSameProductRef(left: DtoAdditionalProductRef, right: DtoAdditionalProductRef): boolean;
-export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithLang, right: DtoCatalogueParamsWithLang) => boolean;
-export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithLang, right: DtoProductParamsWithLang) => boolean;
+export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithCidAndLang, right: DtoCatalogueParamsWithCidAndLang) => boolean;
+export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithCidAndLang, right: DtoProductParamsWithCidAndLang) => boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map

package/dist/utilitiesCatalogueData.js

@@ -25,6 +25,13 @@ export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
     p += "_}";
     return p;
 }, "");
+/**
+ * Deep compare. Uses the JSON.stringify method for comparison
+ * @returns true if equal. Key and array order is respected.
+ */
+export function compareCfgProductData(pd1, pd2) {
+    return JSON.stringify(pd1) === JSON.stringify(pd2);
+}
 export function isModel(arg) {
     return typeof arg === "object" && arg !== null && "cid" in arg && "uri" in arg;
 }

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,10 +1,10 @@
-import { DtoCatalogueParams, DtoCataloguePermission } from "./CatalogueAPI.js";
+import { DtoCatalogueParamsWithCid, DtoCataloguePermission } from "./CatalogueAPI.js";
 interface CataloguePermissionByEnterpriseKey {
     [key: string]: DtoCataloguePermission[];
 }
 export declare const groupAndSortCataloguePermissions: (cataloguePermissions: DtoCataloguePermission[]) => CataloguePermissionByEnterpriseKey;
 export declare const isParamSet: (param: string | undefined) => boolean;
-export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParams>) => (perm: DtoCataloguePermission) => boolean;
+export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParamsWithCid>) => (perm: DtoCataloguePermission) => boolean;
 /**
  * Sometimes you will want to use the latest available prdCatVersion. This method will
  * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
@@ -25,7 +25,7 @@ export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: Dto
  * @param auth
  * @param params
  */
-export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalogueParams, cataloguePermissions: DtoCataloguePermission[]) => string;
+export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalogueParamsWithCid, cataloguePermissions: DtoCataloguePermission[]) => string;
 /**
  * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
  * This method will, if the prdCatVersion is not set, fetch the highest available from the
@@ -34,6 +34,6 @@ export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalo
  * @param auth
  * @param params
  */
-export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParams>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
+export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParamsWithCid>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
 export {};
 //# sourceMappingURL=utilitiesCataloguePermission.d.ts.map