@configura/web-api 2.2.0-alpha.1 → 2.2.0-alpha.3

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -1,589 +1,589 @@
-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 { assert } from "@configura/web-utilities";
-import { CfgProductBubbleMode } from "../CfgProduct.js";
-import { SelectionType, } from "../productConfiguration/CfgFeature.js";
-import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
-import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
-import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
-var AffectedLevel;
-(function (AffectedLevel) {
-    AffectedLevel[AffectedLevel["None"] = 0] = "None";
-    AffectedLevel[AffectedLevel["Initialized"] = 1] = "Initialized";
-    AffectedLevel[AffectedLevel["Set"] = 2] = "Set";
-})(AffectedLevel || (AffectedLevel = {}));
-/**
- * The Transaction is a transient object used to track all the changes made to the supplied
- * SyncGroupState as a result of a (normally) single initial event, like when opening a product
- * or the user selecting an option on an already open product.
- *
- * All state changes are made on an internal copy of the original SyncGroupState (called target)
- * so they can later be used (i.e. committed) at once to the visible product, or safely discarded
- * without affecting anything.
- *
- * The Transaction keeps track of which Features and SyncGroups have been affected so far, to
- * eliminate the risk of infinite loops.
- *
- * Terminology
- * ===========
- *
- * You APPLY things onto the transaction in order to update the sync state inside the transaction.
- * The transaction can then UPDATE other things in order to apply it's sync state onto them.
- *
- * Transaction.applyThing() ...onto the transaction
- * Transaction.updateThing() ...with the transaction
- *
- * @see SyncGroupHandler.ts for more information, including the general resolution algorithm.
- */
-export class SyncGroupsTransaction {
-    constructor(syncState, updateMode, productLoader, original, target, initial) {
-        this._closed = false;
-        this.affectedSelectOneFeatures = new Map();
-        this.affectedSelectManyOptions = new Set();
-        this.affectedSelectOneSyncGroups = new Set();
-        this.affectedSelectManySyncGroupsAndOptions = new Map();
-        this.syncState = syncState.clone();
-        this.originalSyncState = syncState;
-        this.updateMode = updateMode;
-        this.productLoader = productLoader;
-        this.originalProduct = original;
-        this.target = target;
-        this.initial = initial;
-    }
-    static make(syncState, updateMode, product, productLoader, assumeNoStartState) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const t = new this(syncState, updateMode, productLoader, product, yield product.clone(), assumeNoStartState ? undefined : yield product.clone());
-            return t;
-        });
-    }
-    /************************************************************************
-     * Public API (intentionally limited)
-     ************************************************************************/
-    get isClosed() {
-        return this._closed;
-    }
-    close() {
-        this._closed = true;
-    }
-    /**
-     * This is (among other) the entry point when loading a new product.
-     *
-     * @returns true if at least one Feature changed it state. This is a bit counter intuitive,
-     * but as this method will hand over to applyProduct 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.
-     */
-    applyRootProduct() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const productWithInitial = { target: this.target, initial: this.initial };
-            if (!(yield this.applyProduct(productWithInitial))) {
-                // All done!
-                return false;
-            }
-            return yield this.updateRootProduct(undefined);
-        });
-    }
-    /**
-     * This is the entry point for an active (often user) selection of an option.
-     */
-    selectOption(optionPath, on) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const option = SyncGroupsPathHelper.getOptionFromPath(optionPath, this.target);
-            const feature = option.parent;
-            let change = false;
-            let productToValidate = undefined;
-            // At this point in handling sync groups we go back to normal selecting.
-            //
-            // This is because a normal selection can bring features into scope which should push to or
-            // (if the SyncGroup is defined) pull from the Sync State.
-            //
-            // We use BubbleSelected (without validation) as we can delay the validation until after we
-            // have applied the SyncGroup (if any).
-            if (yield feature.selectOption(option, on, ProductConfigurationBubbleMode.BubbleSelected)) {
-                productToValidate = feature.parentProduct;
-                change = true;
-                switch (feature.selectionType) {
-                    case SelectionType.SelectOne:
-                        this.affectedSelectOneFeatures.set(feature, AffectedLevel.Set);
-                        break;
-                    case SelectionType.SelectMany:
-                        this.affectedSelectManyOptions.add(option);
-                        break;
-                    default:
-                        throw new Error("Should not happen");
-                }
-            }
-            switch (feature.selectionType) {
-                case SelectionType.SelectOne:
-                    this.applySelectOneFeature(feature, true, false);
-                    break;
-                case SelectionType.SelectMany:
-                    this.applySelectManyOption(option, true);
-                    break;
-            }
-            if (yield this.updateRootProduct(productToValidate)) {
-                change = true;
-            }
-            return change;
-        });
-    }
-    /**
-     * Overwrites the original Product and SyncGroupState (supplied when creating the Transaction)
-     * with the internal versions inside this Transaction.
-     *
-     * @throws error if the transaction has already been closed.
-     */
-    commit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert(this.isClosed === false, "Trying to commit a closed Transaction");
-            this.originalSyncState.copyFrom(this.syncState);
-            yield this.originalProduct.copyFrom(this.target, false, this.productLoader);
-        });
-    }
-    /************************************************************************
-     * Updating things with the Transaction's SyncState
-     ************************************************************************/
-    /**
-     * Apply current sync groups on those who wants to listen until there is no more to settle.
-     * @returns true if at least one Feature changed selected Option
-     */
-    updateRootProduct(productToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const productsToValidate = new Set();
-            if (productToValidate !== undefined) {
-                productsToValidate.add(productToValidate);
-            }
-            const productWithInitial = { target: this.target, initial: this.initial };
-            yield this.updateProduct(productWithInitial, productsToValidate);
-            if (productsToValidate.size === 0) {
-                // All have been settled, continue to pullPhase
-                return yield this.applyRootProduct();
-            }
-            if (this.isClosed) {
-                // 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, this.productLoader, true));
-            }
-            const revalidationResults = yield Promise.all(promises);
-            if (revalidationResults.every((r) => !r)) {
-                this.close();
-                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 this.updateRootProduct(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.
-     */
-    updateProduct(product, productsToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = [];
-            promises.push(this.updateFeatures(getFeaturesFromProduct(product), productsToValidate));
-            for (const additionalProduct of getAdditionalProducts(product)) {
-                promises.push(this.updateProduct(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.
-     */
-    updateFeatures(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 this.updateFeature(feature, productsToValidate)) {
-                    case "stop":
-                        return;
-                    case "recurseDown":
-                        yield this.updateOptions(getSelectedOptions(feature), productsToValidate);
-                        return;
-                }
-            })));
-        });
-    }
-    /**
-     * Applies the SyncState to an array of Options.
-     * @param productsToValidate To this all products that will need validation are added.
-     */
-    updateOptions(options, productsToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(options.map((option) => {
-                return this.updateFeatures(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.
-     */
-    updateFeature(featureWithInitial, productsToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const feature = featureWithInitial.target;
-            const syncCode = feature.getSyncCode("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 this.updateSelectOneFeature(syncCode, featureWithInitial, productsToValidate);
-                case SelectionType.SelectMany:
-                    return yield this.updateSelectManyFeature(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.
-     */
-    updateSelectOneFeature(syncCode, featureWithInitial, productsToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const feature = featureWithInitial.target;
-            const featureDidJustComeIntoScope = featureWithInitial.initial === undefined;
-            const hasBeenAffectedLevel = this.affectedSelectOneFeatures.get(feature);
-            const syncGroupHasBeenUpdated = this.affectedSelectOneSyncGroups.has(syncCode);
-            if (hasBeenAffectedLevel === AffectedLevel.Set ||
-                (!syncGroupHasBeenUpdated && hasBeenAffectedLevel === AffectedLevel.Initialized)) {
-                // A feature can change value for two reasons:
-                // 1. The feature did just come into scope and loads from the sync group to set its "defaults"
-                // 2. The sync group has updated with a new value
-                // The rule is that in one sync group transaction the feature value is allowed to be updated
-                // once or twice. Once for initialization and once for new sync group value. But they have to
-                // happen in the right order.
-                return "recurseDown";
-            }
-            if (!featureDidJustComeIntoScope && !syncGroupHasBeenUpdated) {
-                return "recurseDown";
-            }
-            const currentSyncGroupValue = this.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);
-            this.affectedSelectOneFeatures.set(feature, syncGroupHasBeenUpdated ? AffectedLevel.Set : AffectedLevel.Initialized);
-            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.
-     */
-    updateSelectManyFeature(syncCode, feature, productsToValidate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const optionsToContinueDown = [];
-            for (const option of getOptions(feature)) {
-                switch (yield this.updateSelectManyOption(syncCode, option, productsToValidate)) {
-                    case "stop":
-                        continue;
-                    case "recurseDown":
-                        optionsToContinueDown.push(option);
-                        continue;
-                }
-            }
-            yield this.updateOptions(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.
-     */
-    updateSelectManyOption(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 (this.affectedSelectManyOptions.has(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;
-            }
-            if (!featureDidJustComeIntoScope &&
-                !this.hasSyncGroupAffectedForSelectMany(syncCode, option)) {
-                return "recurseDown";
-            }
-            const syncGroupValueForOption = this.syncState.getForSelectMany(syncCode, option.code);
-            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);
-            this.affectedSelectManyOptions.add(option);
-            productsToValidate.add(feature.parentProduct);
-            return "stop";
-        });
-    }
-    /************************************************************************
-     * Applying things to the Transaction's SyncState
-     ************************************************************************/
-    applyProduct(product) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let change = false;
-            if (yield this.applyFeatures(getFeaturesFromProduct(product))) {
-                if (this.updateMode === SyncGroupsApplyMode.Strict) {
-                    return true;
-                }
-                change = true;
-            }
-            for (const additionalProduct of getAdditionalProducts(product)) {
-                if (yield this.applyProduct(additionalProduct)) {
-                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
-                        return true;
-                    }
-                    change = true;
-                }
-            }
-            return change;
-        });
-    }
-    applyFeatures(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 (this.applySelectOneFeature(feature, false, featureWithInitial.initial === undefined)) {
-                            change = true;
-                        }
-                        break;
-                    case SelectionType.SelectMany:
-                        if (this.applySelectManyFeature(featureWithInitial)) {
-                            change = true;
-                        }
-                        break;
-                }
-                if (change && this.updateMode === SyncGroupsApplyMode.Strict) {
-                    return true;
-                }
-                if (yield this.applyOptions(getSelectedOptions(featureWithInitial))) {
-                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
-                        return true;
-                    }
-                    change = true;
-                }
-            }
-            return change;
-        });
-    }
-    applyOptions(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let change = false;
-            for (const option of options) {
-                if (yield this.applyFeatures(getFeaturesFromOption(option))) {
-                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
-                        return true;
-                    }
-                    change = true;
-                }
-            }
-            return change;
-        });
-    }
-    applySelectOneFeature(feature, userInitiated, featureDidJustComeIntoScope) {
-        const selectionType = feature.selectionType;
-        if (selectionType !== SelectionType.SelectOne) {
-            throw new Error("can only be used for selectOne");
-        }
-        const syncCode = feature.getSyncCode("push");
-        if (syncCode === undefined || syncCode === false) {
-            return false;
-        }
-        if (this.affectedSelectOneSyncGroups.has(syncCode)) {
-            return false;
-        }
-        const currentSyncGroupOptionCode = this.syncState.getForSelectOne(syncCode);
-        const option = feature.selectedOptions[0];
-        if (option === undefined) {
-            // Options with no default are never written
-            return false;
-        }
-        if (userInitiated) {
-            // To make re-apply happen, even if it actually does not update the sync group
-            this.affectedSelectOneSyncGroups.add(syncCode);
-        }
-        if (option.code === 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 (!(userInitiated ||
-            currentSyncGroupOptionCode === undefined ||
-            (featureDidJustComeIntoScope &&
-                feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
-            return false;
-        }
-        this.affectedSelectOneSyncGroups.add(syncCode);
-        this.syncState.setForSelectOne(syncCode, option.code);
-        return true;
-    }
-    applySelectManyFeature(featureWithInitial) {
-        let change = false;
-        for (const optionWithInitial of getOptions(featureWithInitial)) {
-            if (this.applySelectManyOption(optionWithInitial.target, false)) {
-                if (this.updateMode === SyncGroupsApplyMode.Strict) {
-                    return true;
-                }
-                change = true;
-            }
-        }
-        return change;
-    }
-    applySelectManyOption(option, userInitiated) {
-        const feature = option.parent;
-        if (feature.selectionType !== SelectionType.SelectMany) {
-            throw new Error("can only be used for selectMany");
-        }
-        const syncCode = feature.getSyncCode("push");
-        if (syncCode === undefined || syncCode === false) {
-            return false;
-        }
-        if (this.hasSyncGroupAffectedForSelectMany(syncCode, option)) {
-            return false;
-        }
-        const optionSelected = option.selected;
-        const currentSyncGroupValue = this.syncState.getForSelectMany(syncCode, option.code);
-        if (userInitiated) {
-            // To make re-apply happen, even if it actually does not update the sync group
-            this.addSyncGroupAffectedForSelectMany(syncCode, option);
-        }
-        // We only initialize if the option has not been initiated or if it is userInitiated.
-        // userInitiated = active selection by the user.
-        if (currentSyncGroupValue !== undefined &&
-            !(userInitiated && currentSyncGroupValue !== optionSelected)) {
-            return false;
-        }
-        this.addSyncGroupAffectedForSelectMany(syncCode, option);
-        this.syncState.setForSelectMany(syncCode, option.code, optionSelected);
-        return true;
-    }
-    addSyncGroupAffectedForSelectMany(syncCode, option) {
-        let forSyncCode = this.affectedSelectManySyncGroupsAndOptions.get(syncCode);
-        if (forSyncCode === undefined) {
-            forSyncCode = new Set();
-            this.affectedSelectManySyncGroupsAndOptions.set(syncCode, forSyncCode);
-        }
-        forSyncCode.add(option.code);
-    }
-    hasSyncGroupAffectedForSelectMany(syncCode, option) {
-        var _a;
-        return ((_a = this.affectedSelectManySyncGroupsAndOptions.get(syncCode)) === null || _a === void 0 ? void 0 : _a.has(option.code)) === true;
-    }
-}
-function getAdditionalProducts(product) {
-    const initial = product.initial;
-    return product.target.additionalProducts
-        .filter((p) => p.selected)
-        .map((childTarget) => {
-        const refKey = childTarget.refKey;
-        const childInitial = initial === null || initial === void 0 ? void 0 : initial.additionalProducts.find((p) => refKey === p.refKey);
-        return {
-            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 code = childTarget.code;
-        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => code === f.code);
-        return {
-            target: childTarget._internal,
-            initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,
-        };
-    });
-}
-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);
-}
+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 { assert } from "@configura/web-utilities";
+import { CfgProductBubbleMode } from "../CfgProduct.js";
+import { SelectionType, } from "../productConfiguration/CfgFeature.js";
+import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.js";
+var AffectedLevel;
+(function (AffectedLevel) {
+    AffectedLevel[AffectedLevel["None"] = 0] = "None";
+    AffectedLevel[AffectedLevel["Initialized"] = 1] = "Initialized";
+    AffectedLevel[AffectedLevel["Set"] = 2] = "Set";
+})(AffectedLevel || (AffectedLevel = {}));
+/**
+ * The Transaction is a transient object used to track all the changes made to the supplied
+ * SyncGroupState as a result of a (normally) single initial event, like when opening a product
+ * or the user selecting an option on an already open product.
+ *
+ * All state changes are made on an internal copy of the original SyncGroupState (called target)
+ * so they can later be used (i.e. committed) at once to the visible product, or safely discarded
+ * without affecting anything.
+ *
+ * The Transaction keeps track of which Features and SyncGroups have been affected so far, to
+ * eliminate the risk of infinite loops.
+ *
+ * Terminology
+ * ===========
+ *
+ * You APPLY things onto the transaction in order to update the sync state inside the transaction.
+ * The transaction can then UPDATE other things in order to apply it's sync state onto them.
+ *
+ * Transaction.applyThing() ...onto the transaction
+ * Transaction.updateThing() ...with the transaction
+ *
+ * @see SyncGroupHandler.ts for more information, including the general resolution algorithm.
+ */
+export class SyncGroupsTransaction {
+    constructor(syncState, updateMode, productLoader, original, target, initial) {
+        this._closed = false;
+        this.affectedSelectOneFeatures = new Map();
+        this.affectedSelectManyOptions = new Set();
+        this.affectedSelectOneSyncGroups = new Set();
+        this.affectedSelectManySyncGroupsAndOptions = new Map();
+        this.syncState = syncState.clone();
+        this.originalSyncState = syncState;
+        this.updateMode = updateMode;
+        this.productLoader = productLoader;
+        this.originalProduct = original;
+        this.target = target;
+        this.initial = initial;
+    }
+    static make(syncState, updateMode, product, productLoader, assumeNoStartState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const t = new this(syncState, updateMode, productLoader, product, yield product.clone(), assumeNoStartState ? undefined : yield product.clone());
+            return t;
+        });
+    }
+    /************************************************************************
+     * Public API (intentionally limited)
+     ************************************************************************/
+    get isClosed() {
+        return this._closed;
+    }
+    close() {
+        this._closed = true;
+    }
+    /**
+     * This is (among other) the entry point when loading a new product.
+     *
+     * @returns true if at least one Feature changed it state. This is a bit counter intuitive,
+     * but as this method will hand over to applyProduct 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.
+     */
+    applyRootProduct() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const productWithInitial = { target: this.target, initial: this.initial };
+            if (!(yield this.applyProduct(productWithInitial))) {
+                // All done!
+                return false;
+            }
+            return yield this.updateRootProduct(undefined);
+        });
+    }
+    /**
+     * This is the entry point for an active (often user) selection of an option.
+     */
+    selectOption(optionPath, on) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const option = SyncGroupsPathHelper.getOptionFromPath(optionPath, this.target);
+            const feature = option.parent;
+            let change = false;
+            let productToValidate = undefined;
+            // At this point in handling sync groups we go back to normal selecting.
+            //
+            // This is because a normal selection can bring features into scope which should push to or
+            // (if the SyncGroup is defined) pull from the Sync State.
+            //
+            // We use BubbleSelected (without validation) as we can delay the validation until after we
+            // have applied the SyncGroup (if any).
+            if (yield feature.selectOption(option, on, ProductConfigurationBubbleMode.BubbleSelected)) {
+                productToValidate = feature.parentProduct;
+                change = true;
+                switch (feature.selectionType) {
+                    case SelectionType.SelectOne:
+                        this.affectedSelectOneFeatures.set(feature, AffectedLevel.Set);
+                        break;
+                    case SelectionType.SelectMany:
+                        this.affectedSelectManyOptions.add(option);
+                        break;
+                    default:
+                        throw new Error("Should not happen");
+                }
+            }
+            switch (feature.selectionType) {
+                case SelectionType.SelectOne:
+                    this.applySelectOneFeature(feature, true, false);
+                    break;
+                case SelectionType.SelectMany:
+                    this.applySelectManyOption(option, true);
+                    break;
+            }
+            if (yield this.updateRootProduct(productToValidate)) {
+                change = true;
+            }
+            return change;
+        });
+    }
+    /**
+     * Overwrites the original Product and SyncGroupState (supplied when creating the Transaction)
+     * with the internal versions inside this Transaction.
+     *
+     * @throws error if the transaction has already been closed.
+     */
+    commit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert(this.isClosed === false, "Trying to commit a closed Transaction");
+            this.originalSyncState.copyFrom(this.syncState);
+            yield this.originalProduct.copyFrom(this.target, false, this.productLoader);
+        });
+    }
+    /************************************************************************
+     * Updating things with the Transaction's SyncState
+     ************************************************************************/
+    /**
+     * Apply current sync groups on those who wants to listen until there is no more to settle.
+     * @returns true if at least one Feature changed selected Option
+     */
+    updateRootProduct(productToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const productsToValidate = new Set();
+            if (productToValidate !== undefined) {
+                productsToValidate.add(productToValidate);
+            }
+            const productWithInitial = { target: this.target, initial: this.initial };
+            yield this.updateProduct(productWithInitial, productsToValidate);
+            if (productsToValidate.size === 0) {
+                // All have been settled, continue to pullPhase
+                return yield this.applyRootProduct();
+            }
+            if (this.isClosed) {
+                // 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, this.productLoader, true));
+            }
+            const revalidationResults = yield Promise.all(promises);
+            if (revalidationResults.every((r) => !r)) {
+                this.close();
+                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 this.updateRootProduct(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.
+     */
+    updateProduct(product, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            promises.push(this.updateFeatures(getFeaturesFromProduct(product), productsToValidate));
+            for (const additionalProduct of getAdditionalProducts(product)) {
+                promises.push(this.updateProduct(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.
+     */
+    updateFeatures(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 this.updateFeature(feature, productsToValidate)) {
+                    case "stop":
+                        return;
+                    case "recurseDown":
+                        yield this.updateOptions(getSelectedOptions(feature), productsToValidate);
+                        return;
+                }
+            })));
+        });
+    }
+    /**
+     * Applies the SyncState to an array of Options.
+     * @param productsToValidate To this all products that will need validation are added.
+     */
+    updateOptions(options, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(options.map((option) => {
+                return this.updateFeatures(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.
+     */
+    updateFeature(featureWithInitial, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const feature = featureWithInitial.target;
+            const syncCode = feature.getSyncCode("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 this.updateSelectOneFeature(syncCode, featureWithInitial, productsToValidate);
+                case SelectionType.SelectMany:
+                    return yield this.updateSelectManyFeature(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.
+     */
+    updateSelectOneFeature(syncCode, featureWithInitial, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const feature = featureWithInitial.target;
+            const featureDidJustComeIntoScope = featureWithInitial.initial === undefined;
+            const hasBeenAffectedLevel = this.affectedSelectOneFeatures.get(feature);
+            const syncGroupHasBeenUpdated = this.affectedSelectOneSyncGroups.has(syncCode);
+            if (hasBeenAffectedLevel === AffectedLevel.Set ||
+                (!syncGroupHasBeenUpdated && hasBeenAffectedLevel === AffectedLevel.Initialized)) {
+                // A feature can change value for two reasons:
+                // 1. The feature did just come into scope and loads from the sync group to set its "defaults"
+                // 2. The sync group has updated with a new value
+                // The rule is that in one sync group transaction the feature value is allowed to be updated
+                // once or twice. Once for initialization and once for new sync group value. But they have to
+                // happen in the right order.
+                return "recurseDown";
+            }
+            if (!featureDidJustComeIntoScope && !syncGroupHasBeenUpdated) {
+                return "recurseDown";
+            }
+            const currentSyncGroupValue = this.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);
+            this.affectedSelectOneFeatures.set(feature, syncGroupHasBeenUpdated ? AffectedLevel.Set : AffectedLevel.Initialized);
+            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.
+     */
+    updateSelectManyFeature(syncCode, feature, productsToValidate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const optionsToContinueDown = [];
+            for (const option of getOptions(feature)) {
+                switch (yield this.updateSelectManyOption(syncCode, option, productsToValidate)) {
+                    case "stop":
+                        continue;
+                    case "recurseDown":
+                        optionsToContinueDown.push(option);
+                        continue;
+                }
+            }
+            yield this.updateOptions(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.
+     */
+    updateSelectManyOption(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 (this.affectedSelectManyOptions.has(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;
+            }
+            if (!featureDidJustComeIntoScope &&
+                !this.hasSyncGroupAffectedForSelectMany(syncCode, option)) {
+                return "recurseDown";
+            }
+            const syncGroupValueForOption = this.syncState.getForSelectMany(syncCode, option.code);
+            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);
+            this.affectedSelectManyOptions.add(option);
+            productsToValidate.add(feature.parentProduct);
+            return "stop";
+        });
+    }
+    /************************************************************************
+     * Applying things to the Transaction's SyncState
+     ************************************************************************/
+    applyProduct(product) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let change = false;
+            if (yield this.applyFeatures(getFeaturesFromProduct(product))) {
+                if (this.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                change = true;
+            }
+            for (const additionalProduct of getAdditionalProducts(product)) {
+                if (yield this.applyProduct(additionalProduct)) {
+                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    applyFeatures(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 (this.applySelectOneFeature(feature, false, featureWithInitial.initial === undefined)) {
+                            change = true;
+                        }
+                        break;
+                    case SelectionType.SelectMany:
+                        if (this.applySelectManyFeature(featureWithInitial)) {
+                            change = true;
+                        }
+                        break;
+                }
+                if (change && this.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                if (yield this.applyOptions(getSelectedOptions(featureWithInitial))) {
+                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    applyOptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let change = false;
+            for (const option of options) {
+                if (yield this.applyFeatures(getFeaturesFromOption(option))) {
+                    if (this.updateMode === SyncGroupsApplyMode.Strict) {
+                        return true;
+                    }
+                    change = true;
+                }
+            }
+            return change;
+        });
+    }
+    applySelectOneFeature(feature, userInitiated, featureDidJustComeIntoScope) {
+        const selectionType = feature.selectionType;
+        if (selectionType !== SelectionType.SelectOne) {
+            throw new Error("can only be used for selectOne");
+        }
+        const syncCode = feature.getSyncCode("push");
+        if (syncCode === undefined || syncCode === false) {
+            return false;
+        }
+        if (this.affectedSelectOneSyncGroups.has(syncCode)) {
+            return false;
+        }
+        const currentSyncGroupOptionCode = this.syncState.getForSelectOne(syncCode);
+        const option = feature.selectedOptions[0];
+        if (option === undefined) {
+            // Options with no default are never written
+            return false;
+        }
+        if (userInitiated) {
+            // To make re-apply happen, even if it actually does not update the sync group
+            this.affectedSelectOneSyncGroups.add(syncCode);
+        }
+        if (option.code === 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 (!(userInitiated ||
+            currentSyncGroupOptionCode === undefined ||
+            (featureDidJustComeIntoScope &&
+                feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
+            return false;
+        }
+        this.affectedSelectOneSyncGroups.add(syncCode);
+        this.syncState.setForSelectOne(syncCode, option.code);
+        return true;
+    }
+    applySelectManyFeature(featureWithInitial) {
+        let change = false;
+        for (const optionWithInitial of getOptions(featureWithInitial)) {
+            if (this.applySelectManyOption(optionWithInitial.target, false)) {
+                if (this.updateMode === SyncGroupsApplyMode.Strict) {
+                    return true;
+                }
+                change = true;
+            }
+        }
+        return change;
+    }
+    applySelectManyOption(option, userInitiated) {
+        const feature = option.parent;
+        if (feature.selectionType !== SelectionType.SelectMany) {
+            throw new Error("can only be used for selectMany");
+        }
+        const syncCode = feature.getSyncCode("push");
+        if (syncCode === undefined || syncCode === false) {
+            return false;
+        }
+        if (this.hasSyncGroupAffectedForSelectMany(syncCode, option)) {
+            return false;
+        }
+        const optionSelected = option.selected;
+        const currentSyncGroupValue = this.syncState.getForSelectMany(syncCode, option.code);
+        if (userInitiated) {
+            // To make re-apply happen, even if it actually does not update the sync group
+            this.addSyncGroupAffectedForSelectMany(syncCode, option);
+        }
+        // We only initialize if the option has not been initiated or if it is userInitiated.
+        // userInitiated = active selection by the user.
+        if (currentSyncGroupValue !== undefined &&
+            !(userInitiated && currentSyncGroupValue !== optionSelected)) {
+            return false;
+        }
+        this.addSyncGroupAffectedForSelectMany(syncCode, option);
+        this.syncState.setForSelectMany(syncCode, option.code, optionSelected);
+        return true;
+    }
+    addSyncGroupAffectedForSelectMany(syncCode, option) {
+        let forSyncCode = this.affectedSelectManySyncGroupsAndOptions.get(syncCode);
+        if (forSyncCode === undefined) {
+            forSyncCode = new Set();
+            this.affectedSelectManySyncGroupsAndOptions.set(syncCode, forSyncCode);
+        }
+        forSyncCode.add(option.code);
+    }
+    hasSyncGroupAffectedForSelectMany(syncCode, option) {
+        var _a;
+        return ((_a = this.affectedSelectManySyncGroupsAndOptions.get(syncCode)) === null || _a === void 0 ? void 0 : _a.has(option.code)) === true;
+    }
+}
+function getAdditionalProducts(product) {
+    const initial = product.initial;
+    return product.target.additionalProducts
+        .filter((p) => p.selected)
+        .map((childTarget) => {
+        const refKey = childTarget.refKey;
+        const childInitial = initial === null || initial === void 0 ? void 0 : initial.additionalProducts.find((p) => refKey === p.refKey);
+        return {
+            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 code = childTarget.code;
+        const childInitial = initials === null || initials === void 0 ? void 0 : initials.find((f) => code === f.code);
+        return {
+            target: childTarget._internal,
+            initial: childInitial === null || childInitial === void 0 ? void 0 : childInitial._internal,
+        };
+    });
+}
+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);
+}