@configura/web-api 1.6.1-alpha.7 → 1.6.1

package/dist/productConfiguration/CfgFeature.js

@@ -7,10 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { compareArrays, convertLength, count, Observable, someMatch, toLengthUnit, } from "@configura/web-utilities";
+import { assertDefined, compareArrays, convertLength, count, Observable, someMatch, toLengthUnit, } from "@configura/web-utilities";
 import { CfgProduct } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { CfgMtrlApplicationSource } from "../material/CfgMtrlApplicationSource.js";
+import { wrapWithCache } from "../productLoader.js";
 import { CfgOption, ProductConfigurationBubbleMode } from "./CfgOption.js";
 import { _CfgProductConfigurationInternal } from "./CfgProductConfiguration.js";
 import { getMtrlPreview } from "./utilitiesProductConfiguration.js";
@@ -188,25 +189,13 @@ export class _CfgFeatureInternal {
                         console.warn(wrongCountWarning);
                     }
                 }
-                if (!isGroup) {
-                    const apiSelectionCount = Object.keys(apiOptionSelectionMap).length;
-                    if (selectionCount !== apiSelectionCount) {
-                        const wrongCountWarning = `All provided Options are expected to be selected. Feature key: "${this.key}". Expected: ${apiSelectionCount} Actual: ${selectionCount}`;
-                        if (this.rootProduct.settings.strictSetApiSelectionMatch) {
-                            throw new Error(wrongCountWarning);
-                        }
-                        else {
-                            console.warn(wrongCountWarning);
-                        }
-                    }
-                }
             }
             if (change) {
                 if (isAllOptionsAffectedByAnySelection) {
                     this._freshRefAllOptions();
                 }
                 if (selectionType === SelectionType.SelectOne) {
-                    this.pushStretch();
+                    yield this.pushStretch();
                 }
                 // setApiSelection works its way top down and handles notifications on
                 // each level by looking at change returned from its children. That way
@@ -301,11 +290,19 @@ export class _CfgFeatureInternal {
             return change;
         });
         /**
-         * Normally this is used through methods on CfgFeature and CfgOption. Use this
-         * internal version if you need to control the bubbleMode.
+         * Normally this is used through methods on CfgFeature and CfgOption. Use this internal version
+         * if you need to control the bubbleMode.
+         *
          * Using a validate bubbleMode will cause validation calls to the server.
          */
         this.selectOption = (optionInternal, on, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+            if (bubbleMode ===
+                ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups) {
+                const product = this.rootProduct;
+                const syncGroupHandler = product.syncGroupHandler;
+                assertDefined(syncGroupHandler, `Sync group handler is required for bubble mode ${ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups}`);
+                return yield syncGroupHandler.selectOption(product, optionInternal, on, wrapWithCache(product._productLoaderRaw));
+            }
             if (!on) {
                 if (this.selectionType === SelectionType.Group) {
                     throw new Error(`Multiple features are always selected and are not user selectable. Feature key: "${this.key}".`);
@@ -318,50 +315,59 @@ export class _CfgFeatureInternal {
             const isAllOptionsAffectedByAnySelection = this.isAllOptionsAffectedByAnySelection;
             const index = selectedOptions.findIndex(getOptionFilter(optionInternal));
             const isActualChange = (index === -1) === on;
-            if (on) {
-                // Calling this.options will populate (generate) all Options if they have not yet
-                // been generated. As we are selecting an option we need all Options to be generated.
-                const options = this.options;
-                if (this.selectionType === SelectionType.SelectOne) {
-                    let removeOption = selectedOptions.shift();
-                    while (removeOption !== undefined) {
-                        if (!isAllOptionsAffectedByAnySelection) {
-                            doFreshRefOption(options, removeOption._internal);
+            if (this.selectionType !== SelectionType.Group) {
+                if (on) {
+                    // Calling this.options will populate (generate) all Options if they have not yet
+                    // been generated. As we are selecting an option we need all Options to be generated.
+                    const options = this.options;
+                    if (this.selectionType === SelectionType.SelectOne) {
+                        let removeOption = selectedOptions.shift();
+                        while (removeOption !== undefined) {
+                            if (!isAllOptionsAffectedByAnySelection) {
+                                doFreshRefOption(options, removeOption._internal);
+                            }
+                            removeOption = selectedOptions.shift();
                         }
-                        removeOption = selectedOptions.shift();
                     }
-                }
-                if (isAllOptionsAffectedByAnySelection) {
-                    selectedOptions.push(CfgOption._makeNewRefFrom(optionInternal));
+                    if (isAllOptionsAffectedByAnySelection) {
+                        selectedOptions.push(CfgOption._makeNewRefFrom(optionInternal));
+                    }
+                    else {
+                        doFreshRefOption(options, optionInternal, (freshRef) => selectedOptions.push(freshRef));
+                    }
+                    if (this.selectionType === SelectionType.SelectOne) {
+                        yield this.pushStretch();
+                    }
                 }
                 else {
-                    doFreshRefOption(options, optionInternal, (freshRef) => selectedOptions.push(freshRef));
+                    selectedOptions.splice(index, 1);
+                    if (!isAllOptionsAffectedByAnySelection) {
+                        // Accessing this._options gives us the Options that have been generated
+                        // or undefined if the Options have not yet been generated. As this action
+                        // is deselect and deselected is the default uninitialized state we can
+                        // safely ignore if undefined.
+                        const options = this._options;
+                        if (options !== undefined) {
+                            doFreshRefOption(options, optionInternal);
+                        }
+                    }
                 }
-                if (this.selectionType === SelectionType.SelectOne) {
-                    yield this.pushStretch();
+                if (isAllOptionsAffectedByAnySelection) {
+                    this._freshRefAllOptions();
                 }
             }
-            else {
-                selectedOptions.splice(index, 1);
-                if (!isAllOptionsAffectedByAnySelection) {
-                    // Accessing this._options gives us the Options that have been generated
-                    // or undefined if the Options have not yet been generated. As this action
-                    // is deselect and deselected is the default uninitialized state we can
-                    // safely ignore if undefined.
-                    const options = this._options;
-                    if (options !== undefined) {
-                        doFreshRefOption(options, optionInternal);
-                    }
+            let nextLevelBubbleMode = bubbleMode;
+            if (!on) {
+                // If this was a deselect action we shall not bubble selected, that is, we shall not
+                // select the ancestors if this action was deselect.
+                if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected) {
+                    nextLevelBubbleMode = ProductConfigurationBubbleMode.Validate;
+                }
+                else if (bubbleMode === ProductConfigurationBubbleMode.BubbleSelected) {
+                    nextLevelBubbleMode = ProductConfigurationBubbleMode.ToRoot;
                 }
             }
-            if (isAllOptionsAffectedByAnySelection) {
-                this._freshRefAllOptions();
-            }
-            // If this was a deselect action we shall not bubble selected, that is, we shall not
-            // select the ancestors if this action was deselect.
-            yield this._notifyAllOfChange(!on && bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected
-                ? ProductConfigurationBubbleMode.Validate
-                : bubbleMode);
+            yield this._notifyAllOfChange(nextLevelBubbleMode);
             return isActualChange;
         });
         this.isSelected = (option) => this.selectionType === SelectionType.Group ||
@@ -415,6 +421,25 @@ export class _CfgFeatureInternal {
     get description() {
         return this.rawFeature.description;
     }
+    get syncGroup() {
+        return this.rawFeature.syncGroup;
+    }
+    /**
+     * @return one of the following, in order:
+     * - undefined if the Feature lacks a syncGroup.
+     * - false if the syncGroup doesn't fulfill the optional mustSupport requirement.
+     * - syncCode from the syncGroup.
+     */
+    getSyncCode(mustSupport) {
+        if (this.syncGroup === undefined) {
+            return undefined;
+        }
+        const { syncGroupCode, syncMethod } = this.syncGroup;
+        if (mustSupport === undefined || syncMethod === "twoWay" || syncMethod === mustSupport) {
+            return syncGroupCode;
+        }
+        return false;
+    }
     /**
      * The MeasureParam class is re-used for different purposes. In Features it is used
      * to indicate which stretch measures inside Models shall be affected by this state
@@ -531,7 +556,7 @@ export class CfgFeature {
          * Calling this will cause a validation call to the server.
          */
         this.selectOption = (option, on) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._internal.selectOption(option._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelected);
+            return yield this._internal.selectOption(option._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups);
         });
         this.isSelected = (option) => this._internal.isSelected(option._internal);
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);

package/dist/productConfiguration/CfgOption.d.ts

@@ -10,16 +10,25 @@ export declare type OptionChangeNotification = {
 };
 export declare enum ProductConfigurationBubbleMode {
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate.
+     * If this is select it will turns on all ancestors all the way up.
+     */
+    BubbleSelected = "BubbleSelected",
+    /**
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate.
      */
     Validate = "Validate",
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate. If this is select it will turns on all ancestors all the way up.
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate. If this is select it will turn on all ancestors all the way up.
      * So with this mode it is possible to select an option where its parents are not selected.
      */
     ValidateAndBubbleSelected = "ValidateAndBubbleSelected",
+    /**
+     * Like ValidateAndBubbleSelected, but SyncGroups are applied after ValidateAndBubbleSelected
+     * has been done
+     */
+    ValidateAndBubbleSelectedAndApplySyncGroups = "ValidateAndBubbleSelectedAndApplySyncGroups",
     /**
      * Stop bubbling
      * This mode supports internal functionality and is not expected to be used by integrators.
@@ -44,10 +53,9 @@ export declare enum ProductConfigurationBubbleMode {
     ToRoot = "ToRoot"
 }
 /**
- * This class is meant to only be used through CfgOption. It should
- * never be instantiated on its own. Normally the internal state of this class
- * should never be directly modified. CfgOption is the class that
- * should be used and interacted with.
+ * This class is only meant to be used through CfgOption. It should never be instantiated on its
+ * own. Normally the internal state of this class should never be directly modified. CfgOption is
+ * the class that should be used and interacted with.
  */
 export declare class _CfgOptionInternal {
     readonly rawOption: Option;
@@ -71,6 +79,7 @@ export declare class _CfgOptionInternal {
     get unit(): LengthUnit;
     get description(): string;
     get selected(): boolean;
+    get selectedChangeInProgress(): boolean;
     get ancestorsSelected(): boolean;
     get mtrlApplications(): CfgMtrlApplication[];
     get thumbnail(): string | undefined;
@@ -116,8 +125,21 @@ export declare class CfgOption {
     get unit(): LengthUnit;
     get description(): string;
     get selected(): boolean;
+    /**
+     * Selection state is in progress to be changed. This can be used in GUI
+     * to display the state as transitioning, or as already changed.
+     * If selectedChangeInProgress and:
+     * selected is true, it means that this is about to get unselected
+     * selected is false, it means that this is about to get selected
+     */
+    get selectedChangeInProgress(): boolean;
     /** Are all ancestors up to the CfgProductConfiguration selected? Includes self. */
     get ancestorsSelected(): boolean;
+    /**
+     * Selects this Option.
+     * Only Options belonging to Features that are "select many" can be deselected.
+     * Calling this will cause a validation call to the server.
+     */
     setSelected: (on: boolean) => Promise<boolean>;
     get thumbnail(): string | undefined;
     get upcharge(): number | undefined;

package/dist/productConfiguration/CfgOption.js

@@ -18,16 +18,25 @@ import { getMtrlPreview, syncCfgFeatures } from "./utilitiesProductConfiguration
 export var ProductConfigurationBubbleMode;
 (function (ProductConfigurationBubbleMode) {
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate.
+     * If this is select it will turns on all ancestors all the way up.
+     */
+    ProductConfigurationBubbleMode["BubbleSelected"] = "BubbleSelected";
+    /**
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate.
      */
     ProductConfigurationBubbleMode["Validate"] = "Validate";
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate. If this is select it will turns on all ancestors all the way up.
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate. If this is select it will turn on all ancestors all the way up.
      * So with this mode it is possible to select an option where its parents are not selected.
      */
     ProductConfigurationBubbleMode["ValidateAndBubbleSelected"] = "ValidateAndBubbleSelected";
+    /**
+     * Like ValidateAndBubbleSelected, but SyncGroups are applied after ValidateAndBubbleSelected
+     * has been done
+     */
+    ProductConfigurationBubbleMode["ValidateAndBubbleSelectedAndApplySyncGroups"] = "ValidateAndBubbleSelectedAndApplySyncGroups";
     /**
      * Stop bubbling
      * This mode supports internal functionality and is not expected to be used by integrators.
@@ -66,10 +75,9 @@ function doesChildrenShareOptionsCode(features) {
     return false;
 }
 /**
- * This class is meant to only be used through CfgOption. It should
- * never be instantiated on its own. Normally the internal state of this class
- * should never be directly modified. CfgOption is the class that
- * should be used and interacted with.
+ * This class is only meant to be used through CfgOption. It should never be instantiated on its
+ * own. Normally the internal state of this class should never be directly modified. CfgOption is
+ * the class that should be used and interacted with.
  */
 export class _CfgOptionInternal {
     constructor(rawOption, allRawFeatures, siblingHasDuplicateDescription, parent, parentConfiguration, parentProduct, rootProduct) {
@@ -93,7 +101,8 @@ export class _CfgOptionInternal {
             features[i] = freshRef;
             // In CfgOption we let stop bubble slip through. This is because CfgOption is sort of
             // a semi level. Like Feature + Option together constitutes one level.
-            if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected) {
+            if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected ||
+                bubbleMode === ProductConfigurationBubbleMode.BubbleSelected) {
                 // selectOption takes care of the bubble
                 yield this.parent.selectOption(this, true, bubbleMode);
             }
@@ -170,9 +179,8 @@ export class _CfgOptionInternal {
             agg.push(...feature._internal._getFeaturesWithCode(code));
             return agg;
         }, []);
-        // Description based key helps when switching between
-        // products with similar feature-options tree and trying
-        // to retain made selection
+        // Description based key helps when switching between products with similar feature-options
+        // tree and trying to retain made selection.
         this.key =
             this.description +
                 (this.description === "" || siblingHasDuplicateDescription ? this.code : "");
@@ -219,9 +227,9 @@ export class _CfgOptionInternal {
                     this._numericValue = val;
                     change = true;
                 }
-                // It could be that even though our value did not change some sibling value did, and this
-                // could make it needed to bubble later. Maybe. A bit uncertain about why I did not put
-                // this in the if-statement above //Linus
+                // It could be that even though our value did not change some sibling value did, and
+                // this could make it needed to bubble later. Maybe. A bit uncertain about why I did
+                // not put this in the if-statement above //Linus
                 if (yield this.parent.pushStretch()) {
                     change = true;
                 }
@@ -248,6 +256,20 @@ export class _CfgOptionInternal {
     get selected() {
         return this.parent.isSelected(this);
     }
+    get selectedChangeInProgress() {
+        const syncGroupHandler = this.rootProduct.syncGroupHandler;
+        if (syncGroupHandler === undefined) {
+            return false;
+        }
+        const inProgressOption = syncGroupHandler.pending;
+        if (inProgressOption === this) {
+            return true;
+        }
+        if (!(this.selected && this.parent.selectionType === SelectionType.SelectOne)) {
+            return false;
+        }
+        return this.parent.options.some((o) => o._internal === inProgressOption);
+    }
     get ancestorsSelected() {
         return this.selected && this.parent.ancestorsSelected;
     }
@@ -320,13 +342,13 @@ export class CfgOption {
         this.isBackedBySame = (other) => this._internal === other._internal;
         this.setNumericValue = (val, doSelectOption) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setNumericValue(val, doSelectOption); });
         this.isAllowedNumericValue = (val) => this._internal.isAllowedNumericValue(val);
-        /*
+        /**
          * Selects this Option.
          * Only Options belonging to Features that are "select many" can be deselected.
          * Calling this will cause a validation call to the server.
          */
         this.setSelected = (on) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._internal.parent.selectOption(this._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelected);
+            return yield this._internal.parent.selectOption(this._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups);
         });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
@@ -375,6 +397,16 @@ export class CfgOption {
     get selected() {
         return this._internal.selected;
     }
+    /**
+     * Selection state is in progress to be changed. This can be used in GUI
+     * to display the state as transitioning, or as already changed.
+     * If selectedChangeInProgress and:
+     * selected is true, it means that this is about to get unselected
+     * selected is false, it means that this is about to get selected
+     */
+    get selectedChangeInProgress() {
+        return this._internal.selectedChangeInProgress;
+    }
     /** Are all ancestors up to the CfgProductConfiguration selected? Includes self. */
     get ancestorsSelected() {
         return this._internal.ancestorsSelected;

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -43,7 +43,7 @@ export declare class _CfgProductConfigurationInternal {
      * outside we want notifications to bubble all the way to the root.
      */
     setApiSelection: (selectedOptions: SelectedOption[], bubbleToRoot: boolean) => Promise<boolean>;
-    structureCompare: (other: _CfgProductConfigurationInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
+    structureCompare: (other: _CfgProductConfigurationInternal, strictOrder: boolean, descriptionMatch: boolean) => boolean;
     /**
      * 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.

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -74,7 +74,7 @@ export class _CfgProductConfigurationInternal {
             }
             return change;
         });
-        this.structureCompare = (other, strictOrder = true, descriptionMatch = false) => compareArrays(this.features, other.features, (l, r) => l._internal.structureCompare(r._internal, strictOrder, descriptionMatch), strictOrder);
+        this.structureCompare = (other, strictOrder, descriptionMatch) => compareArrays(this.features, other.features, (l, r) => l._internal.structureCompare(r._internal, strictOrder, descriptionMatch), strictOrder);
         /**
          * 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.
@@ -129,7 +129,7 @@ export class _CfgProductConfigurationInternal {
                 return false;
             }
             const stretchReferenceLengthsByMeasureParamCode = this.stretchReferenceLengthsByMeasureParamCode;
-            let stretchReferenceLength = stretchReferenceLengthsByMeasureParamCode.get(measureParamCode);
+            const stretchReferenceLength = stretchReferenceLengthsByMeasureParamCode.get(measureParamCode);
             const referenceLengthWithUnit = {
                 length: referenceLength,
                 unit,
@@ -151,6 +151,7 @@ export class _CfgProductConfigurationInternal {
             }
             return true;
         });
+        /* eslint-disable */
         // Useful debug tool:
         if (false) {
             const dbgName = `conf${parentProduct.refKey || parentProduct.key}`;
@@ -158,6 +159,7 @@ export class _CfgProductConfigurationInternal {
             window.conf = this;
             console.log(`Use "window['${dbgName}']" or window.conf to access conf.`);
         }
+        /* eslint-enable */
         /**
          * 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

package/dist/productConfiguration/filters.js

@@ -1,10 +1,10 @@
 import { match, pick } from "@configura/web-utilities";
 export function applyCatalogueFilters(filters, catalogues) {
-    let enterprise = match("enterprise", filters.enterprise, catalogues);
-    let prdCat = match("prdCat", filters.prdCat, enterprise.matching);
-    let prdCatVersion = match("prdCatVersion", filters.prdCatVersion, prdCat.matching);
-    let vendor = match("vendor", filters.vendor, prdCatVersion.matching);
-    let priceList = match("priceList", filters.priceList, vendor.matching);
+    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);
@@ -48,9 +48,9 @@ export function cloneFilterSortLevels(levels, prdRefsFilter, showEmpty, doSort =
             newPrdRefs = level.prdRefs.filter((prod) => prdRefsFilter.some((p) => p.partNr === prod.prdRef));
         }
         // add copy of level if not empty
-        let addPrdRefs = showEmpty || (newPrdRefs !== undefined && newPrdRefs.length > 0);
+        const addPrdRefs = showEmpty || (newPrdRefs !== undefined && newPrdRefs.length > 0);
         if (nextLevels !== undefined || addPrdRefs) {
-            let newLevel = {
+            const newLevel = {
                 code: level.code,
                 description: level.description,
             };

package/dist/syncGroups/SyncGroupsApplyMode.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState.
+ *
+ * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
+ * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
+ *
+ * The downside of this is that is not exactly how CET (the desktop software) works. CET will
+ * instead apply Features to the SyncState as soon as it gets the chance.
+ *
+ * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
+ * calls, increasing delay and cost.
+ *
+ * Strict is the safer option of the two, but we still recommend trying out Fast since it should
+ * work fine in most cases.
+ */
+export declare enum SyncGroupsApplyMode {
+    Strict = "Strict",
+    Fast = "Fast"
+}
+//# sourceMappingURL=SyncGroupsApplyMode.d.ts.map

package/dist/syncGroups/SyncGroupsApplyMode.js

@@ -0,0 +1,21 @@
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState.
+ *
+ * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
+ * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
+ *
+ * The downside of this is that is not exactly how CET (the desktop software) works. CET will
+ * instead apply Features to the SyncState as soon as it gets the chance.
+ *
+ * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
+ * calls, increasing delay and cost.
+ *
+ * Strict is the safer option of the two, but we still recommend trying out Fast since it should
+ * work fine in most cases.
+ */
+export var SyncGroupsApplyMode;
+(function (SyncGroupsApplyMode) {
+    SyncGroupsApplyMode["Strict"] = "Strict";
+    SyncGroupsApplyMode["Fast"] = "Fast";
+})(SyncGroupsApplyMode || (SyncGroupsApplyMode = {}));

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -0,0 +1,41 @@
+import { AggregatedLoadingObservable } from "@configura/web-utilities";
+import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { ProductLoader } from "../productLoader.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
+export declare type SyncCode = string;
+export declare type OptionCode = string;
+/**
+ * Is used to apply the SyncGroups functionality on the Configuration and the other way around.
+ * It also keeps the SyncState.
+ */
+export declare class SyncGroupsHandler {
+    private _syncState;
+    readonly updateMode: SyncGroupsApplyMode;
+    private readonly _loadingObservable;
+    private _currentTransaction;
+    /**
+     * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
+     */
+    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable, verboseLogging?: boolean): SyncGroupsHandler;
+    private constructor();
+    /** Please note that clones will use the same loadingObservable as their source. */
+    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". */
+    init(product: _CfgProductInternal, productLoader: ProductLoader): Promise<void>;
+    /**
+     * Used when an Option is selected or deselected to apply all consequences of the sync groups.
+     * Can cause multiple extra validation calls to the server.
+     */
+    selectOption(product: _CfgProductInternal, option: _CfgOptionInternal, on: boolean, productLoader: ProductLoader): Promise<boolean>;
+    private _pending;
+    private setPending;
+    get pending(): _CfgOptionInternal | undefined;
+    private newTransaction;
+    private closeTransaction;
+    commitTransaction(transaction: SyncGroupsTransaction): Promise<void>;
+}
+//# sourceMappingURL=SyncGroupsHandler.d.ts.map