@configura/web-api 1.4.0 → 1.6.0-alpha.0

package/dist/productLoader.js

@@ -1,49 +1,49 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { PromiseCache } from "@configura/web-utilities";
-import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js";
-/**
- * Wraps a getProduct function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. For this reason we recommend using this with caution.
- *
- * In our Example App we use it to cache the internal calls in additional products as in such a
- * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
- * four times.
- */
-export function wrapWithGetProductCache(getProduct) {
-    const cache = new PromiseCache();
-    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params, params.partNumber), () => getProduct(params)); });
-}
-/**
- * Wraps a postValidate function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. We recommend you do not use this unless you are really, really sure what you are
- * doing.
- *
- * The SDK uses it for additional products to avoid validating for example the same table legs four
- * times at the same time. There we make sure the this cache only stays in scope for one user
- * interaction. No longer than the actions caused by a user clicking an option.
- */
-export function wrapWithPostValidateCache(postValidate) {
-    const cache = new PromiseCache();
-    return (params, body) => __awaiter(this, void 0, void 0, function* () {
-        return cache.get(`${makeProductKey(params, params.partNumber)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
-    });
-}
-/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
-export function wrapWithCache(loader) {
-    return {
-        getProduct: wrapWithGetProductCache(loader.getProduct.bind(loader)),
-        postValidate: wrapWithPostValidateCache(loader.postValidate.bind(loader)),
-    };
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PromiseCache } from "@configura/web-utilities";
+import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js";
+/**
+ * Wraps a getProduct function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. For this reason we recommend using this with caution.
+ *
+ * In our Example App we use it to cache the internal calls in additional products as in such a
+ * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
+ * four times.
+ */
+export function wrapWithGetProductCache(getProduct) {
+    const cache = new PromiseCache();
+    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params, params.partNumber), () => getProduct(params)); });
+}
+/**
+ * Wraps a postValidate function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. We recommend you do not use this unless you are really, really sure what you are
+ * doing.
+ *
+ * The SDK uses it for additional products to avoid validating for example the same table legs four
+ * times at the same time. There we make sure the this cache only stays in scope for one user
+ * interaction. No longer than the actions caused by a user clicking an option.
+ */
+export function wrapWithPostValidateCache(postValidate) {
+    const cache = new PromiseCache();
+    return (params, body) => __awaiter(this, void 0, void 0, function* () {
+        return cache.get(`${makeProductKey(params, params.partNumber)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
+    });
+}
+/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
+export function wrapWithCache(loader) {
+    return {
+        getProduct: wrapWithGetProductCache(loader.getProduct.bind(loader)),
+        postValidate: wrapWithPostValidateCache(loader.postValidate.bind(loader)),
+    };
+}

package/dist/syncGroups/SyncGroupsApplier.d.ts

@@ -0,0 +1,20 @@
+import { SyncGroup } from "../CatalogueAPI.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { SyncCode } from "./SyncGroupsHandler.js";
+import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
+export declare class SyncGroupsApplier {
+    /**
+     * At load of a new product this is used to move it into a synced state
+     */
+    static init(transaction: SyncGroupsTransaction): Promise<boolean>;
+    /**
+     * At an active select of an option this is the entry point
+     */
+    static selectOption(transaction: SyncGroupsTransaction, option: _CfgOptionInternal, on: boolean): Promise<boolean>;
+    /**
+     * @returns undefined if the @syncGroup is undefined, false if
+     * the @mustSupport is not fulfilled or the syncCode if all is ok
+     */
+    static getSyncCode(syncGroup: SyncGroup | undefined, mustSupport: "push" | "pull"): SyncCode | undefined | false;
+}
+//# sourceMappingURL=SyncGroupsApplier.d.ts.map

package/dist/syncGroups/SyncGroupsApplier.js

@@ -0,0 +1,518 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { CfgProductBubbleMode } from "../CfgProduct.js";
+import { SelectionType, } from "../productConfiguration/CfgFeature.js";
+import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+export class SyncGroupsApplier {
+    /**
+     * At load of a new product this is used to move it into a synced state
+     */
+    static init(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield OntoSyncState.rootProduct(transaction);
+        });
+    }
+    /**
+     * At an active select of an option this is the entry point
+     */
+    static selectOption(transaction, option, on) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const feature = option.parent;
+            const productsToValidate = new Set();
+            let change = false;
+            // Here we sort of hand back to normal selecting. This is because after a normal selection has happened
+            // this can have brought features into scope which should pull or push to the Sync State. (Push if the
+            // SyncGroup is yet undefined)
+            // We use BubbleSelected as we can then delay the validation until after we have applied the sync group (if any)
+            if (yield feature.selectOption(option, on, ProductConfigurationBubbleMode.BubbleSelected)) {
+                productsToValidate.add(feature.parentProduct);
+                switch (feature.selectionType) {
+                    case SelectionType.SelectOne:
+                        transaction.addSelectOneFeatureAffected(feature);
+                        break;
+                    case SelectionType.SelectMany:
+                        transaction.addSelectManyOptionAffected(option);
+                        break;
+                    default:
+                        throw new Error("Should not happen");
+                }
+                change = true;
+            }
+            switch (feature.selectionType) {
+                case SelectionType.SelectOne:
+                    OntoSyncState.selectOneFeature(transaction, feature, true, false);
+                    break;
+                case SelectionType.SelectMany:
+                    OntoSyncState.selectManyOption(transaction, option, true);
+                    break;
+            }
+            if (yield SyncStateOnto.rootProduct(transaction, productsToValidate)) {
+                change = true;
+            }
+            return change;
+        });
+    }
+    /**
+     * @returns undefined if the @syncGroup is undefined, false if
+     * the @mustSupport is not fulfilled or the syncCode if all is ok
+     */
+    static getSyncCode(syncGroup, mustSupport) {
+        if (syncGroup === undefined) {
+            return undefined;
+        }
+        const { syncGroupCode, syncMethod } = syncGroup;
+        if (syncMethod !== mustSupport && syncMethod !== "twoWay") {
+            return false;
+        }
+        return syncGroupCode;
+    }
+}
+class SyncStateOnto {
+    /**
+     * Apply current sync groups on those who wants to listen until no more to settle
+     * @returns true if at least one Feature changed selected Option
+     */
+    static rootProduct(transaction, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            productsToValidate = productsToValidate !== null && productsToValidate !== void 0 ? productsToValidate : new Set();
+            yield SyncStateOnto.product(transaction, transaction, productsToValidate);
+            if (productsToValidate.size === 0) {
+                // All settled, continue to pullPhase
+                return yield OntoSyncState.rootProduct(transaction);
+            }
+            if (transaction.isAborted) {
+                // We could exit in more places when the transaction has been aborted,
+                // but as revalidate is really the only thing that could be expensive /
+                // time consuming we only check here.
+                return false;
+            }
+            const promises = [];
+            for (const product of productsToValidate) {
+                promises.push(product._revalidate(CfgProductBubbleMode.ToRoot, transaction.productLoader));
+            }
+            const revalidationResults = yield Promise.all(promises);
+            // When using SyncGroups we require each and every validate call to validate on the
+            // server. Without SyncGroups we let these pass through, because any diversion from
+            // what you did chose should be immediately visible. With SyncGroups the end result
+            // is the combination of potentially many different validate calls, and so errors
+            // could accumulate and what is cause and effect be hard to know.
+            if (revalidationResults.some((r) => r.wasAborted || !r.requestDidValidate)) {
+                transaction.abort();
+                return false;
+            }
+            // Apply over again, to settle deeper down. Our theory is that the front of
+            // "settled" will move deeper and deeper into the tree.
+            yield SyncStateOnto.rootProduct(transaction, undefined);
+            // We had productsToValidate, and so there must have been a change
+            return true;
+        });
+    }
+    /**
+     * Applies the SyncState to the Product and it's AdditionalProducts (sub-products)
+     * @param productsToValidate To this all products that will need validation are added
+     */
+    static product(transaction, product, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            promises.push(SyncStateOnto.features(transaction, getFeaturesFromProduct(product), productsToValidate));
+            for (const additionalProduct of getAdditionalProducts(product)) {
+                promises.push(SyncStateOnto.product(transaction, additionalProduct, productsToValidate));
+            }
+            yield Promise.all(promises);
+        });
+    }
+    /**
+     * Applies the SyncState to an array of Features
+     * @param productsToValidate To this all products that will need validation are added
+     */
+    static features(transaction, features, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(features.map((feature) => __awaiter(this, void 0, void 0, function* () {
+                switch (yield SyncStateOnto.feature(transaction, feature, productsToValidate)) {
+                    case "stop":
+                        return;
+                    case "recurseDown":
+                        yield SyncStateOnto.options(transaction, getSelectedOptions(feature), productsToValidate);
+                        return;
+                }
+            })));
+        });
+    }
+    /**
+     * Applies the SyncState to an array of Options
+     * @param productsToValidate To this all products that will need validation are added
+     */
+    static options(transaction, options, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(options.map((option) => {
+                return SyncStateOnto.features(transaction, getFeaturesFromOption(option), productsToValidate);
+            }));
+        });
+    }
+    /**
+     * Applies the SyncState to a Feature
+     * @param productsToValidate To this all products that will need validation are added
+     * @returns Whether we shall stop recursing down (because we are in a state which we
+     * expect to be resolved later), we shall continue recursing down.
+     */
+    static feature(transaction, featureWithInitial, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const feature = featureWithInitial.target;
+            const syncCode = SyncGroupsApplier.getSyncCode(feature.syncGroup, "pull");
+            if (syncCode === undefined) {
+                // Just continue down, features with no sync groups are always settled
+                return "recurseDown";
+            }
+            if (syncCode === false) {
+                // Here we only handle pull. Initializing those missing in SyncMap
+                // we do later. We wait until we have settled as much as we can with what
+                // we have now, to increase chances of the values being written to the
+                // SyncState being the right ones.
+                return "stop";
+            }
+            switch (feature.selectionType) {
+                case SelectionType.Group:
+                    return "recurseDown";
+                case SelectionType.SelectOne:
+                    return yield SyncStateOnto.selectOneFeature(transaction, syncCode, featureWithInitial, productsToValidate);
+                case SelectionType.SelectMany:
+                    return yield SyncStateOnto.selectManyFeature(transaction, syncCode, featureWithInitial, productsToValidate);
+            }
+        });
+    }
+    /**
+     * Decides if the SyncState can be applied to the SelectOne Feature, and then changes
+     * the state of the Feature if so.
+     * @param syncCode What SyncGroup the Feature belongs to
+     * @param productsToValidate To this all products that will need validation are added
+     * @returns Whether we shall stop recursing down (because we are in a state which we
+     * expect to be resolved later), we shall continue recursing down.
+     */
+    static selectOneFeature(transaction, syncCode, featureWithInitial, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const feature = featureWithInitial.target;
+            const featureDidJustComeIntoScope = featureWithInitial.initial === undefined;
+            if (transaction.hasSelectOneFeatureBeenAffected(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.
+                return "recurseDown";
+            }
+            if (!(featureDidJustComeIntoScope || transaction.isSyncGroupAffectedForSelectOne(syncCode))) {
+                return "recurseDown";
+            }
+            const currentSyncGroupValue = transaction.syncState.getForSelectOne(syncCode);
+            if (currentSyncGroupValue === undefined) {
+                // This branch will have to be settled later. Don't go further down here.
+                return "stop";
+            }
+            const selectedOption = feature.selectedOptions[0];
+            if (selectedOption !== undefined && selectedOption.code === currentSyncGroupValue) {
+                // Settled, continue
+                return "recurseDown";
+            }
+            const optionToSelect = feature.options.find((o) => o.code === currentSyncGroupValue);
+            if (optionToSelect === undefined) {
+                // No option which can be selected (keep current value and recurse down)
+                return "recurseDown";
+            }
+            // Update the value. Validations are collected so that we do not
+            // send more than necessary. 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);
+            transaction.addSelectOneFeatureAffected(feature);
+            productsToValidate.add(feature.parentProduct);
+            return "stop";
+        });
+    }
+    /**
+     * Decides if the SyncState can be applied to Options in the SelectMany Feature, and
+     * then changes the state of the Options if so.
+     * @param syncCode What SyncGroup the Feature belongs to
+     * @param productsToValidate To this all products that will need validation are added
+     * @returns Always "stop" as recursion is handled internally. Return for consistency.
+     */
+    static selectManyFeature(transaction, syncCode, feature, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const optionsToContinueDown = [];
+            for (const option of getOptions(feature)) {
+                switch (yield SyncStateOnto.selectManyOption(transaction, syncCode, option, productsToValidate)) {
+                    case "stop":
+                        continue;
+                    case "recurseDown":
+                        optionsToContinueDown.push(option);
+                        continue;
+                }
+            }
+            yield SyncStateOnto.options(transaction, optionsToContinueDown, productsToValidate);
+            // stop as the method above handles the recursion down
+            return "stop";
+        });
+    }
+    /**
+     * Decides if the SyncState can be applied to the SelectMany Option, and then changes
+     * the state of the Option if so.
+     * @param syncCode What SyncGroup the Feature belongs to
+     * @param productsToValidate To this all products that will need validation are added
+     * @returns Whether we shall stop recursing down (because we are in a state which we
+     * expect to be resolved later), we shall continue recursing down.
+     */
+    static selectManyOption(transaction, syncCode, optionWithInitial, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const option = optionWithInitial.target;
+            const featureDidJustComeIntoScope = optionWithInitial.initial === undefined;
+            const optionSelected = option.selected;
+            const recurseOrStopIfNoChange = optionSelected ? "recurseDown" : "stop";
+            if (transaction.hasSelectManyOptionBeenAffected(option)) {
+                // This option 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.
+                return recurseOrStopIfNoChange;
+            }
+            const optionCode = option.code;
+            if (!(featureDidJustComeIntoScope ||
+                transaction.isSyncGroupAffectedForSelectMany(syncCode, optionCode))) {
+                return "recurseDown";
+            }
+            const syncGroupValueForOption = transaction.syncState.getForSelectMany(syncCode, optionCode);
+            if (syncGroupValueForOption === undefined) {
+                // The sync group has no opinion on this. If it is selected, just continue down.
+                return recurseOrStopIfNoChange;
+            }
+            if (syncGroupValueForOption === optionSelected) {
+                // We are in sync for this option
+                return recurseOrStopIfNoChange;
+            }
+            const feature = option.parent;
+            // Update the value. Validations are collected so that we do not
+            // send more than necessary. Do not recurse further as we will change
+            // the state and so what is selected now won't be selected then.
+            yield feature.selectOption(option, syncGroupValueForOption, ProductConfigurationBubbleMode.ToRoot);
+            transaction.addSelectManyOptionAffected(option);
+            productsToValidate.add(feature.parentProduct);
+            return "stop";
+        });
+    }
+}
+class OntoSyncState {
+    /**
+     * @returns true if at least one Feature changed it state. This is a bit counter intuitive,
+     * but as this method will hand over to productOntoSyncState if it updates the SyncState it
+     * can cause the Features to change. And we need to pass that information back to know when
+     * to stop
+     */
+    static rootProduct(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield OntoSyncState.product(transaction, transaction))) {
+                // All done!
+                return false;
+            }
+            return yield SyncStateOnto.rootProduct(transaction, undefined);
+        });
+    }
+    static product(transaction, product) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let change = false;
+            if (yield OntoSyncState.features(transaction, getFeaturesFromProduct(product))) {
+                if (transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                change = true;
+            }
+            for (const additionalProduct of getAdditionalProducts(product)) {
+                if (yield OntoSyncState.product(transaction, additionalProduct)) {
+                    if (transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    static features(transaction, featureWithInitials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let change = false;
+            for (const featureWithInitial of featureWithInitials) {
+                const feature = featureWithInitial.target;
+                switch (feature.selectionType) {
+                    case SelectionType.SelectOne:
+                        if (OntoSyncState.selectOneFeature(transaction, feature, false, featureWithInitial.initial === undefined)) {
+                            change = true;
+                        }
+                        break;
+                    case SelectionType.SelectMany:
+                        if (OntoSyncState.selectManyFeature(transaction, featureWithInitial)) {
+                            change = true;
+                        }
+                        break;
+                }
+                if (change && transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                if (yield OntoSyncState.options(transaction, getSelectedOptions(featureWithInitial))) {
+                    if (transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    static options(transaction, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let change = false;
+            for (const option of options) {
+                if (yield OntoSyncState.features(transaction, getFeaturesFromOption(option))) {
+                    if (transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    static selectOneFeature(transaction, feature, activeSelectionForce, featureDidJustComeIntoScope) {
+        const selectionType = feature.selectionType;
+        if (selectionType !== SelectionType.SelectOne) {
+            throw new Error("can only be used for selectOne");
+        }
+        const syncCode = SyncGroupsApplier.getSyncCode(feature.syncGroup, "push");
+        if (syncCode === undefined || syncCode === false) {
+            return false;
+        }
+        if (transaction.isSyncGroupAffectedForSelectOne(syncCode)) {
+            return false;
+        }
+        const syncState = transaction.syncState;
+        const currentSyncGroupOptionCode = syncState.getForSelectOne(syncCode);
+        const option = feature.selectedOptions[0];
+        if (option === undefined) {
+            // Options with no default are never written
+            return false;
+        }
+        if (activeSelectionForce) {
+            // To make re-apply happen, even if it actually does not update the sync group
+            transaction.addSyncGroupAffectedForSelectOne(syncCode);
+        }
+        const optionCode = option.code;
+        if (optionCode === currentSyncGroupOptionCode) {
+            return false;
+        }
+        // featureDidJustComeIntoScope, in CET there is a feature that if a feature appears which 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 ||
+            currentSyncGroupOptionCode === undefined ||
+            (featureDidJustComeIntoScope &&
+                feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
+            return false;
+        }
+        syncState.logDebug();
+        transaction.addSyncGroupAffectedForSelectOne(syncCode);
+        syncState.setForSelectOne(syncCode, optionCode);
+        return true;
+    }
+    static selectManyFeature(transaction, featureWithInitial) {
+        let change = false;
+        for (const optionWithInitial of getOptions(featureWithInitial)) {
+            if (OntoSyncState.selectManyOption(transaction, optionWithInitial.target, false)) {
+                if (transaction.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                change = true;
+            }
+        }
+        return change;
+    }
+    static selectManyOption(transaction, option, activeSelectionForce) {
+        const feature = option.parent;
+        if (feature.selectionType !== SelectionType.SelectMany) {
+            throw new Error("can only be used for selectMany");
+        }
+        const syncCode = SyncGroupsApplier.getSyncCode(feature.syncGroup, "push");
+        if (syncCode === undefined || syncCode === false) {
+            return false;
+        }
+        const optionCode = option.code;
+        if (transaction.isSyncGroupAffectedForSelectMany(syncCode, optionCode)) {
+            return false;
+        }
+        const syncState = transaction.syncState;
+        const optionSelected = option.selected;
+        const currentSyncGroupValue = syncState.getForSelectMany(syncCode, optionCode);
+        if (activeSelectionForce) {
+            // To make re-apply happen, even if it actually does not update the sync group
+            transaction.addSyncGroupAffectedForSelectMany(syncCode, optionCode);
+        }
+        // We only initialize if the option is selected or we force.
+        // activeSelectionForce = active selection by the user.
+        if (!(currentSyncGroupValue === undefined && optionSelected) &&
+            !(activeSelectionForce && currentSyncGroupValue !== optionSelected)) {
+            return false;
+        }
+        transaction.addSyncGroupAffectedForSelectMany(syncCode, optionCode);
+        syncState.setForSelectMany(syncCode, optionCode, optionSelected);
+        return true;
+    }
+}
+function getAdditionalProducts(product) {
+    const initial = product.initial;
+    return product.target.additionalProducts.map((childTarget) => {
+        const refKey = childTarget.refKey;
+        const childInitial = initial === null || initial === void 0 ? void 0 : initial.additionalProducts.find((p) => refKey === p.refKey);
+        return {
+            target: childTarget._internal,
+            initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,
+        };
+    });
+}
+function pairOptions(targets, initials) {
+    return targets.map((childTarget) => {
+        const key = childTarget.key;
+        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((o) => key === o.key);
+        return {
+            target: childTarget._internal,
+            initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,
+        };
+    });
+}
+function getSelectedOptions(feature) {
+    var _a;
+    return pairOptions(feature.target.selectedOptions, (_a = feature.initial) === null || _a === void 0 ? void 0 : _a.selectedOptions);
+}
+function getOptions(feature) {
+    var _a;
+    return pairOptions(feature.target.options, (_a = feature.initial) === null || _a === void 0 ? void 0 : _a.options);
+}
+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);
+        return {
+            target: childTarget._internal,
+            initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,
+        };
+    });
+}
+function getFeaturesFromProduct(product) {
+    var _a;
+    return pairFeatures(product.target.configuration.features, (_a = product.initial) === null || _a === void 0 ? void 0 : _a.configuration.features);
+}
+function getFeaturesFromOption(option) {
+    var _a;
+    return pairFeatures(option.target.features, (_a = option.initial) === null || _a === void 0 ? void 0 : _a.features);
+}

package/dist/syncGroups/SyncGroupsApplyMode.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState (C.). "Fast" is default and will make any SyncGroup that
+ * should be updated update before running syncStateOntoRootProduct (B.) This way several
+ * SyncGroups can be applied in one go before sending validation calls to the server. The
+ * downside of this is that is not exactly how CET (the desktop software) works. CET will apply
+ * Features to the SyncState as soon as it gets the chance. This is the same as running with
+ * "Strict" here. This will potentially generate a lot more validate calls, increasing delay
+ * and cost. So if you don't have to, stick with "Fast".
+ */
+export declare enum SyncGroupsApplyMode {
+    Fast = "Fast",
+    Strict = "Strict"
+}
+//# sourceMappingURL=SyncGroupsApplyMode.d.ts.map

package/dist/syncGroups/SyncGroupsApplyMode.js

@@ -0,0 +1,15 @@
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState (C.). "Fast" is default and will make any SyncGroup that
+ * should be updated update before running syncStateOntoRootProduct (B.) This way several
+ * SyncGroups can be applied in one go before sending validation calls to the server. The
+ * downside of this is that is not exactly how CET (the desktop software) works. CET will apply
+ * Features to the SyncState as soon as it gets the chance. This is the same as running with
+ * "Strict" here. This will potentially generate a lot more validate calls, increasing delay
+ * and cost. So if you don't have to, stick with "Fast".
+ */
+export var SyncGroupsApplyMode;
+(function (SyncGroupsApplyMode) {
+    SyncGroupsApplyMode["Fast"] = "Fast";
+    SyncGroupsApplyMode["Strict"] = "Strict";
+})(SyncGroupsApplyMode || (SyncGroupsApplyMode = {}));