@configura/web-api 1.6.1-alpha.5 → 1.6.2-alpha.0

package/dist/syncGroups/SyncGroupsApplier.js

@@ -1,514 +0,0 @@
-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.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, transaction.productLoader));
-            }
-            const revalidationResults = yield Promise.all(promises);
-            if (revalidationResults.every((r) => !r)) {
-                transaction.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 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;
-        }
-        // TODO: Remove
-        //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);
-}