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

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -9,8 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { compareArrays, count, isEqualLength, isLengthUnit, Observable, toError, toLengthUnit, } from "@configura/web-utilities";
 import { CfgProduct } from "../CfgProduct.js";
-import { convertDtoConfFeaturesToSelOptions } from "../ConfigurationConverter.js";
-import { CfgFeature } from "./CfgFeature.js";
+import { convertDtoFeatureConfsToSelOptions } from "../utilitiesConfiguration.js";
 import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 import { syncCfgFeatures } from "./utilitiesProductConfiguration.js";
 /**
@@ -19,13 +18,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) {
-        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* () {
@@ -56,9 +55,11 @@ export class _CfgProductConfigurationInternal {
             yield this._notifyAllOfChange(bubbleMode, committed);
         });
         this.getDtoConf = (includeExtendedData) => this._features.map((f) => f._internal.getDtoConf(includeExtendedData));
+        this.getApiSelection = () => convertDtoFeatureConfsToSelOptions(this.getDtoConf(false), true);
         /**
          * When used internally the notifications are taken care off by the caller, but if set from
          * outside we want notifications to bubble all the way to the root.
+         * This method will not cause validation calls. Data is assumed to already be validated.
          */
         this.setApiSelection = (selectedOptions, bubbleToRoot) => __awaiter(this, void 0, void 0, function* () {
             const featuresLength = this._features.length;
@@ -111,9 +112,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._features = syncCfgFeatures(rootFeatureRefs, this._features, this.allRawFeatures, this, this, this.parentProduct, this.rootProduct);
+            this._hasRootFeaturesChanged = !compareArrays(this._initialRootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code);
+            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 === "") {
@@ -158,6 +189,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
@@ -194,11 +227,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);
-        configuration.populateFeatures(rootFeatureRefs);
-        return configuration;
+        return new this(rawFeatures, parentProduct, rootProduct, rootFeatureRefs);
     }
     get rootFeatureRefs() {
         return this._rootFeatureRefs;
@@ -207,13 +238,12 @@ export class _CfgProductConfigurationInternal {
     get features() {
         return this._features;
     }
-    _freshRefDescendants() {
-        const features = this._features;
-        for (let i = 0; i < features.length; i++) {
-            const featureInternal = features[i]._internal;
-            featureInternal._freshRefDescendants();
-            features[i] = CfgFeature._makeNewRefFrom(featureInternal);
-        }
+    /**
+     * True if what root Features are used is not the same as at initial load.
+     * This means that functional selection has happened.
+     */
+    get hasRootFeaturesChanged() {
+        return this._hasRootFeaturesChanged;
     }
 }
 export class CfgProductConfiguration {
@@ -233,12 +263,6 @@ export class CfgProductConfiguration {
          */
         this.tryMatchSelection = (other, descriptionMatch = false // Match on case insensitive description, not code
         ) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.tryMatchSelection(other._internal, descriptionMatch, true); });
-        this.getApiSelection = () => convertDtoConfFeaturesToSelOptions(this._internal.getDtoConf(false), true);
-        /**
-         * This method does not propagate its selections.
-         * This method will not cause validation calls. Data is assumed to already be validated.
-         */
-        this.setApiSelection = (selectedOptions) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(selectedOptions, true); });
         /**
          * Set how stretched a certain measure should be measureParamCode is the measure to be
          * stretched referenceLength is a value relative to the initial length of the measure. If the
@@ -259,9 +283,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
@@ -289,12 +313,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,10 +1,12 @@
-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 { Filters } from "@configura/web-utilities";
+import { DtoCatalogueParams, DtoLevel, DtoProductRef } from "../CatalogueAPI.js";
+export declare function applyCatalogueFilters<T extends DtoCatalogueParams>(filters: Filters<DtoCatalogueParams>, catalogues: T[]): [{
+    [K in keyof DtoCatalogueParams]: string[];
+}, T[]];
 export interface ProductRefParams {
     partNr: string;
 }
-export declare function applyProductRefFilters(filters: Filters<ProductRefParams>, productRefs: DtoProductRef[]): [Matches<ProductRefParams>, DtoProductRef[]];
+export declare function applyProductRefFilters(filters: Filters<ProductRefParams>, productRefs: DtoProductRef[]): [string[], DtoProductRef[]];
 /**
  * Clones the table of content levels tree.
  * Filters to only include passed products.

package/dist/productConfiguration/filters.js

@@ -1,31 +1,102 @@
-import { match, pick } from "@configura/web-utilities";
+import { shuffle } from "@configura/web-utilities";
+function filterAndSort(propertyValuesToT, property, filtersByProperty, availablePropertyValuesByProperty) {
+    const availablePropertyValues = availablePropertyValuesByProperty[property];
+    for (const key of propertyValuesToT.keys()) {
+        availablePropertyValues.add(key);
+    }
+    let items;
+    const filter = filtersByProperty[property];
+    if (filter.mode === "exact") {
+        const { value: key } = filter;
+        if (key !== "-") {
+            const item = propertyValuesToT.get(key);
+            if (item === undefined) {
+                items = [];
+            }
+            else {
+                items = [item];
+            }
+        }
+    }
+    if (items === undefined) {
+        if (filter.mode === "random") {
+            items = shuffle(Array.from(propertyValuesToT.values()));
+        }
+        else {
+            items = Array.from(propertyValuesToT.entries())
+                .sort((l, r) => l[0].localeCompare(r[0], undefined, { sensitivity: "base" }))
+                .map((item) => item[1]);
+        }
+        if (filter.value > 0 && (filter.mode === "first" || filter.mode === "random")) {
+            items = items.slice(0, filter.value);
+        }
+    }
+    return items;
+}
+function stringSetToSortedArray(s) {
+    return Array.from(s).sort((l, r) => l.localeCompare(r, undefined, { sensitivity: "base" }));
+}
 export function applyCatalogueFilters(filters, catalogues) {
-    const enterprise = match("enterprise", filters.enterprise, catalogues);
-    const prdCat = match("prdCat", filters.prdCat, enterprise.matching);
-    const prdCatVersion = match("prdCatVersion", filters.prdCatVersion, prdCat.matching);
-    const vendor = match("vendor", filters.vendor, prdCatVersion.matching);
-    const priceList = match("priceList", filters.priceList, vendor.matching);
-    let picked = pick(filters.enterprise, priceList.matching);
-    picked = pick(filters.prdCat, picked);
-    picked = pick(filters.prdCatVersion, picked);
-    picked = pick(filters.vendor, picked);
-    picked = pick(filters.priceList, picked);
-    const matches = {
-        enterprise,
-        prdCat,
-        prdCatVersion,
-        priceList,
-        vendor,
+    const cataloguesAsTree = new Map();
+    for (const catalogueParams of catalogues) {
+        const { enterprise, prdCat, prdCatVersion, vendor, priceList } = catalogueParams;
+        let byEnterprise = cataloguesAsTree.get(enterprise);
+        if (byEnterprise === undefined) {
+            byEnterprise = new Map();
+            cataloguesAsTree.set(enterprise, byEnterprise);
+        }
+        let byPrdCat = byEnterprise.get(prdCat);
+        if (byPrdCat === undefined) {
+            byPrdCat = new Map();
+            byEnterprise.set(prdCat, byPrdCat);
+        }
+        let byPrdCatVersion = byPrdCat.get(prdCatVersion);
+        if (byPrdCatVersion === undefined) {
+            byPrdCatVersion = new Map();
+            byPrdCat.set(prdCatVersion, byPrdCatVersion);
+        }
+        let byVendor = byPrdCatVersion.get(vendor);
+        if (byVendor === undefined) {
+            byVendor = new Map();
+            byPrdCatVersion.set(vendor, byVendor);
+        }
+        if (byVendor.has(priceList)) {
+            console.warn(`Duplicate catalogue ${enterprise} ${prdCat} ${prdCatVersion} ${vendor} ${priceList}`);
+        }
+        else {
+            byVendor.set(priceList, catalogueParams);
+        }
+    }
+    const filteredCatalogues = [];
+    const availablePropertyValues = {
+        enterprise: new Set(),
+        prdCat: new Set(),
+        prdCatVersion: new Set(),
+        vendor: new Set(),
+        priceList: new Set(),
     };
-    return [matches, picked];
+    filterAndSort(cataloguesAsTree, "enterprise", filters, availablePropertyValues).map((item) => filterAndSort(item, "prdCat", filters, availablePropertyValues).map((item) => filterAndSort(item, "prdCatVersion", filters, availablePropertyValues).map((item) => filterAndSort(item, "vendor", filters, availablePropertyValues).map((item) => filterAndSort(item, "priceList", filters, availablePropertyValues).forEach((item) => {
+        filteredCatalogues.push(item);
+    })))));
+    const availablePropertyValuesAsSortedArrays = {
+        enterprise: stringSetToSortedArray(availablePropertyValues.enterprise),
+        prdCat: stringSetToSortedArray(availablePropertyValues.prdCat),
+        prdCatVersion: stringSetToSortedArray(availablePropertyValues.prdCatVersion),
+        vendor: stringSetToSortedArray(availablePropertyValues.vendor),
+        priceList: stringSetToSortedArray(availablePropertyValues.priceList),
+    };
+    return [availablePropertyValuesAsSortedArrays, filteredCatalogues];
 }
 export function applyProductRefFilters(filters, productRefs) {
-    const partNr = match("partNr", filters.partNr, productRefs);
-    const result = pick(filters.partNr, partNr.matching);
-    const args = {
-        partNr,
+    const map = new Map();
+    for (const productRef of productRefs) {
+        map.set(productRef.partNr, productRef);
+    }
+    const availablePropertyValues = {
+        partNr: new Set(),
     };
-    return [args, result];
+    const filtered = filterAndSort(map, "partNr", filters, availablePropertyValues);
+    return [stringSetToSortedArray(availablePropertyValues.partNr), filtered];
 }
 /**
  * Clones the table of content levels tree.

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/productLoader.js

@@ -37,7 +37,7 @@ export function wrapWithGetProductCache(getProduct) {
 export function wrapWithPostValidateCache(postValidate) {
     const cache = new PromiseCache();
     return (params, body) => __awaiter(this, void 0, void 0, function* () {
-        return cache.get(`${makeProductKey(params)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
+        return cache.get(`${makeProductKey(params)}-${makeSelOptionsKey(body.selOptions)}-${body.knownFeatureCodes.join(",")}`, () => postValidate(params, body));
     });
 }
 /** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -1,4 +1,5 @@
 import { AggregatedLoadingObservable } from "@configura/web-utilities";
+import { DtoSyncGroupState } from "../CatalogueAPI.js";
 import { _CfgProductInternal } from "../CfgProduct.js";
 import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
 import { ProductLoader } from "../productLoader.js";
@@ -18,13 +19,19 @@ export declare class SyncGroupsHandler {
     /**
      * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
      */
-    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable, verboseLogging?: boolean): SyncGroupsHandler;
+    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable, initial?: DtoSyncGroupState, verboseLogging?: boolean): SyncGroupsHandler;
     private constructor();
     /** Please note that clones will use the same loadingObservable as their source. */
     clone(): SyncGroupsHandler;
+    getCompactSyncGroupState(): DtoSyncGroupState;
+    /** Overwrites the sync state */
+    setCompactSyncGroupState(s: DtoSyncGroupState): void;
     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.
@@ -262,20 +263,30 @@ export class SyncGroupsHandler {
     /**
      * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
      */
-    static make(updateMode = SyncGroupsApplyMode.Strict, loadingObservable, verboseLogging = false) {
-        return new SyncGroupsHandler(new SyncGroupsState(verboseLogging), updateMode, loadingObservable);
+    static make(updateMode = SyncGroupsApplyMode.Strict, loadingObservable, initial, verboseLogging = false) {
+        return new SyncGroupsHandler(new SyncGroupsState(verboseLogging, initial), updateMode, loadingObservable);
     }
     /** Please note that clones will use the same loadingObservable as their source. */
     clone() {
         return new SyncGroupsHandler(this._syncState.clone(), this.updateMode, this._loadingObservable);
     }
+    getCompactSyncGroupState() {
+        return this._syncState.getCompact();
+    }
+    /** Overwrites the sync state */
+    setCompactSyncGroupState(s) {
+        this._syncState.setCompact(s);
+    }
     get verboseLogging() {
         return this._syncState.verboseLogging;
     }
     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/SyncGroupsState.d.ts

@@ -1,3 +1,4 @@
+import { DtoSyncGroupState } from "../CatalogueAPI.js";
 import { OptionCode, SyncCode } from "./SyncGroupsHandler.js";
 /**
  * The SyncState is used to keep track of the current value of the SyncGroups.
@@ -12,7 +13,7 @@ export declare class SyncGroupsState {
     /**
      * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
      */
-    constructor(_verboseLogging: boolean);
+    constructor(_verboseLogging: boolean, initial: DtoSyncGroupState | undefined);
     get verboseLogging(): boolean;
     /**
      * Set to true to get verbose sync state changes logged to the console.
@@ -31,6 +32,9 @@ export declare class SyncGroupsState {
     setForSelectMany(syncCode: SyncCode, optionCode: OptionCode, selected: boolean): void;
     getForSelectOne(syncCode: SyncCode): OptionCode | undefined;
     getForSelectMany(syncCode: SyncCode, optionCode: OptionCode): boolean | undefined;
+    /** Overrides the current sync state */
+    setCompact(s: DtoSyncGroupState): void;
+    getCompact(): DtoSyncGroupState;
     log(syncCode?: SyncCode, optionCode?: OptionCode, selected?: boolean): void;
 }
 //# sourceMappingURL=SyncGroupsState.d.ts.map

package/dist/syncGroups/SyncGroupsState.js

@@ -8,10 +8,11 @@ export class SyncGroupsState {
     /**
      * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
      */
-    constructor(_verboseLogging) {
+    constructor(_verboseLogging, initial) {
         this._verboseLogging = _verboseLogging;
         this._selectOne = new Map();
         this._selectMany = new Map();
+        this.setCompact(initial !== null && initial !== void 0 ? initial : {});
     }
     get verboseLogging() {
         return this._verboseLogging;
@@ -26,7 +27,7 @@ export class SyncGroupsState {
      * @returns a deep copy of the SyncGroupState.
      */
     clone() {
-        return new SyncGroupsState(this._verboseLogging).copyFrom(this);
+        return new SyncGroupsState(this._verboseLogging, this.getCompact());
     }
     /**
      * Replaces the internal state of this SyncGroupState with a deep copy of the one in source.
@@ -67,6 +68,47 @@ export class SyncGroupsState {
         var _a;
         return (_a = this._selectMany.get(syncCode)) === null || _a === void 0 ? void 0 : _a.get(optionCode);
     }
+    /** Overrides the current sync state */
+    setCompact(s) {
+        this._selectOne.clear();
+        this._selectMany.clear();
+        const { selectOne, selectMany } = s;
+        if (selectOne !== undefined) {
+            for (const { syncCode, optionCode } of selectOne) {
+                this._selectOne.set(syncCode, optionCode);
+            }
+        }
+        if (selectMany !== undefined) {
+            for (const { syncCode, optionCode, selected } of selectMany) {
+                let entry = this._selectMany.get(syncCode);
+                if (entry === undefined) {
+                    entry = new Map();
+                    this._selectMany.set(syncCode, entry);
+                }
+                entry.set(optionCode, selected);
+            }
+        }
+    }
+    getCompact() {
+        const result = {};
+        if (this._selectOne.size !== 0) {
+            const resultSelectOne = [];
+            for (const [syncCode, optionCode] of this._selectOne) {
+                resultSelectOne.push({ syncCode, optionCode });
+            }
+            result.selectOne = resultSelectOne;
+        }
+        if (this._selectMany.size !== 0) {
+            const resultSelectMany = [];
+            for (const [syncCode, optionCodeToSelected] of this._selectMany) {
+                for (const [optionCode, selected] of optionCodeToSelected) {
+                    resultSelectMany.push({ syncCode, optionCode, selected });
+                }
+            }
+            result.selectMany = resultSelectMany;
+        }
+        return result;
+    }
     log(syncCode, optionCode, selected) {
         if (!this._verboseLogging) {
             return;