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

package/dist/syncGroups/SyncGroupsHandler.js

@@ -1,12 +1,3 @@
-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 { SelectionType } from "../productConfiguration/CfgFeature.js";
 import { ProductConfigurationBubbleMode, } from "../productConfiguration/CfgOption.js";
 import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
@@ -239,16 +230,14 @@ import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
  * Send to root for the passed option and any sibling which is selected, provided the Feature
  * is SelectOne. (As that one (should only be one) can be assumed to be affected).
  */
-function notifyOptionAndSelectedSiblings(option) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const committed = false;
-        const parentFeature = option.parent;
-        if (parentFeature.selectionType === SelectionType.SelectOne) {
-            // These only need to be OneLevel, as the final is ToRoot and they share their parent.
-            yield Promise.all(option.parent.selectedOptions.map((o) => parentFeature._childHasChanged(o._internal, ProductConfigurationBubbleMode.OneLevel, committed)));
-        }
-        yield parentFeature._childHasChanged(option, ProductConfigurationBubbleMode.ToRoot, committed);
-    });
+async function notifyOptionAndSelectedSiblings(option) {
+    const committed = false;
+    const parentFeature = option.parent;
+    if (parentFeature.selectionType === SelectionType.SelectOne) {
+        // These only need to be OneLevel, as the final is ToRoot and they share their parent.
+        await Promise.all(option.parent.selectedOptions.map((o) => parentFeature._childHasChanged(o._internal, ProductConfigurationBubbleMode.OneLevel, committed)));
+    }
+    await parentFeature._childHasChanged(option, ProductConfigurationBubbleMode.ToRoot, committed);
 }
 /**
  * Is used to apply the SyncGroups functionality on the Configuration and the other way around.
@@ -287,84 +276,72 @@ export class SyncGroupsHandler {
      * Used to initially apply the sync state onto a new product so that it is "in sync"
      * and to reapply the sync state when an optional additional product is selected.
      */
-    init(product, productLoader) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.newTransaction(product, productLoader, true);
-            try {
-                yield transaction.applyRootProduct();
-                yield this.commitTransaction(transaction);
-            }
-            finally {
-                this.closeTransaction(transaction);
-            }
-        });
+    async init(product, productLoader) {
+        const transaction = await this.newTransaction(product, productLoader, true);
+        try {
+            await transaction.applyRootProduct();
+            await this.commitTransaction(transaction);
+        }
+        finally {
+            this.closeTransaction(transaction);
+        }
     }
     /**
      * Used when an Option is selected or deselected to apply all consequences of the sync groups.
      * Can cause multiple extra validation calls to the server.
      */
-    selectOption(product, option, on, productLoader) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (product.parent !== undefined) {
-                console.info("Normally the product passed shall be the root product");
-            }
-            yield this.setPending(option);
-            const transaction = yield this.newTransaction(product, productLoader, false);
-            try {
-                const change = yield transaction.selectOption(SyncGroupsPathHelper.getPath(option), on);
-                // Always commit the transaction. The change-result above only tells if the
-                // configuration has changed. The SyncState may however also have changed.
-                yield this.commitTransaction(transaction);
-                return change;
-            }
-            finally {
-                if (this._pending === option) {
-                    yield this.setPending(undefined);
-                }
-                this.closeTransaction(transaction);
+    async selectOption(product, option, on, productLoader) {
+        if (product.parent !== undefined) {
+            console.info("Normally the product passed shall be the root product");
+        }
+        await this.setPending(option);
+        const transaction = await this.newTransaction(product, productLoader, false);
+        try {
+            const change = await transaction.selectOption(SyncGroupsPathHelper.getPath(option), on);
+            // Always commit the transaction. The change-result above only tells if the
+            // configuration has changed. The SyncState may however also have changed.
+            await this.commitTransaction(transaction);
+            return change;
+        }
+        finally {
+            if (this._pending === option) {
+                await this.setPending(undefined);
             }
-        });
+            this.closeTransaction(transaction);
+        }
     }
-    setPending(newPending) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const oldPending = this._pending;
-            this._pending = newPending;
-            if (oldPending !== undefined) {
-                yield notifyOptionAndSelectedSiblings(oldPending);
-            }
-            if (newPending !== undefined) {
-                yield notifyOptionAndSelectedSiblings(newPending);
-            }
-        });
+    async setPending(newPending) {
+        const oldPending = this._pending;
+        this._pending = newPending;
+        if (oldPending !== undefined) {
+            await notifyOptionAndSelectedSiblings(oldPending);
+        }
+        if (newPending !== undefined) {
+            await notifyOptionAndSelectedSiblings(newPending);
+        }
     }
     get pending() {
         return this._pending;
     }
-    newTransaction(product, productLoader, assumeNoStartProductState) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._currentTransaction !== undefined) {
-                this.closeTransaction(this._currentTransaction);
-            }
-            const transaction = yield SyncGroupsTransaction.make(this._syncState, this.updateMode, product, productLoader, assumeNoStartProductState);
-            this._currentTransaction = transaction;
-            // The transaction object is used as loading token
-            (_a = this._loadingObservable) === null || _a === void 0 ? void 0 : _a.startChildLoading(transaction);
-            return transaction;
-        });
+    async newTransaction(product, productLoader, assumeNoStartProductState) {
+        if (this._currentTransaction !== undefined) {
+            this.closeTransaction(this._currentTransaction);
+        }
+        const transaction = await SyncGroupsTransaction.make(this._syncState, this.updateMode, product, productLoader, assumeNoStartProductState);
+        this._currentTransaction = transaction;
+        // The transaction object is used as loading token
+        this._loadingObservable?.startChildLoading(transaction);
+        return transaction;
     }
     closeTransaction(transaction) {
-        var _a;
         transaction.close();
-        (_a = this._loadingObservable) === null || _a === void 0 ? void 0 : _a.stopChildLoading(transaction);
+        this._loadingObservable?.stopChildLoading(transaction);
     }
-    commitTransaction(transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (transaction.isClosed) {
-                return;
-            }
-            yield transaction.commit();
-            this.closeTransaction(transaction);
-        });
+    async commitTransaction(transaction) {
+        if (transaction.isClosed) {
+            return;
+        }
+        await transaction.commit();
+        this.closeTransaction(transaction);
     }
 }

package/dist/syncGroups/SyncGroupsPathHelper.js

@@ -34,7 +34,7 @@ export class SyncGroupsPathHelper {
                     case "p": {
                         const refKey = path.shift();
                         const additional = item.additionalProducts.find((p) => p.refKey === refKey);
-                        assertDefined(additional, `Additional product not found "p, ${refKey !== null && refKey !== void 0 ? refKey : ""}, ${path.join(", ")}"`);
+                        assertDefined(additional, `Additional product not found "p, ${refKey ?? ""}, ${path.join(", ")}"`);
                         item = additional._internal;
                         break;
                     }
@@ -43,22 +43,22 @@ export class SyncGroupsPathHelper {
                         item = item.configuration._internal;
                         break;
                     default:
-                        throw new Error(`Unexpected path segment "${segment !== null && segment !== void 0 ? segment : ""}"`);
+                        throw new Error(`Unexpected path segment "${segment ?? ""}"`);
                 }
             }
             else if (item instanceof _CfgProductConfigurationInternal) {
                 const feature = item.features.find((f) => f.code === segment);
-                assertDefined(feature, `Feature not found "${segment !== null && segment !== void 0 ? segment : ""}", ${path.join(", ")}`);
+                assertDefined(feature, `Feature not found "${segment ?? ""}", ${path.join(", ")}`);
                 item = feature._internal;
             }
             else if (item instanceof _CfgFeatureInternal) {
                 const option = item.options.find((o) => o.code === segment);
-                assertDefined(option, `Option not found "${segment !== null && segment !== void 0 ? segment : ""}", ${path.join(", ")}`);
+                assertDefined(option, `Option not found "${segment ?? ""}", ${path.join(", ")}`);
                 item = option._internal;
             }
             else if (item instanceof _CfgOptionInternal) {
                 const feature = item.features.find((o) => o.code === segment);
-                assertDefined(feature, `Feature not found "${segment !== null && segment !== void 0 ? segment : ""}", ${path.join(", ")}`);
+                assertDefined(feature, `Feature not found "${segment ?? ""}", ${path.join(", ")}`);
                 item = feature._internal;
             }
             else {

package/dist/syncGroups/SyncGroupsState.js

@@ -12,7 +12,7 @@ export class SyncGroupsState {
         this._verboseLogging = _verboseLogging;
         this._selectOne = new Map();
         this._selectMany = new Map();
-        this.setCompact(initial !== null && initial !== void 0 ? initial : {});
+        this.setCompact(initial ?? {});
     }
     get verboseLogging() {
         return this._verboseLogging;
@@ -65,8 +65,7 @@ export class SyncGroupsState {
         return this._selectOne.get(syncCode);
     }
     getForSelectMany(syncCode, optionCode) {
-        var _a;
-        return (_a = this._selectMany.get(syncCode)) === null || _a === void 0 ? void 0 : _a.get(optionCode);
+        return this._selectMany.get(syncCode)?.get(optionCode);
     }
     /** Overrides the current sync state */
     setCompact(s) {
@@ -133,11 +132,11 @@ export class SyncGroupsState {
         const styles = [];
         let msg = "";
         if (syncCode !== undefined && isMany) {
-            msg += `%c${optionCode !== null && optionCode !== void 0 ? optionCode : ""}%c in %c${syncCode}%c set to %c${selected ? "on" : "off"}`;
+            msg += `%c${optionCode ?? ""}%c in %c${syncCode}%c set to %c${selected ? "on" : "off"}`;
             styles.push(bold, "", bold, "", bold);
         }
         else if (syncCode !== undefined && !isMany) {
-            msg += `%c${syncCode}%c set to %c${optionCode !== null && optionCode !== void 0 ? optionCode : ""}`;
+            msg += `%c${syncCode}%c set to %c${optionCode ?? ""}`;
             styles.push(bold, "", bold);
         }
         msg += "\n\n%cSync State (single)";

package/dist/syncGroups/SyncGroupsTransaction.d.ts

@@ -1,4 +1,5 @@
 import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
 import { ProductLoader } from "../productLoader.js";
 import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
 import { CfgPath } from "./SyncGroupsPathHelper.js";
@@ -91,7 +92,7 @@ export declare class SyncGroupsTransaction {
      * 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
      */
-    private updateRootProduct;
+    updateRootProduct(productToValidate: _CfgProductInternal | undefined): Promise<boolean>;
     /**
      * Applies the SyncState to the Product and it's AdditionalProducts (sub-products).
      * @param productsToValidate To this all products that will need validation are added.
@@ -149,7 +150,24 @@ export declare class SyncGroupsTransaction {
     private applySelectOneFeature;
     private applySelectManyFeature;
     private applySelectManyOption;
+    /**
+     * Applies the given diff to the transaction's sync state.
+     */
+    applyFromDiff(diffs: _CfgOptionInternal[]): void;
+    /**
+     * Applies the new state for the given option to the transaction's sync state.
+     */
+    private applyNewStateFor;
     private addSyncGroupAffectedForSelectMany;
     private hasSyncGroupAffectedForSelectMany;
 }
+/************************************************************************
+ * Product diffing
+ ************************************************************************/
+/**
+ * Finds all options that have changed in the new product compared to the original product.
+ *
+ * This is used to determine which options need to be updated in the sync state.
+ */
+export declare function generateSelectionDiff(originalProduct: _CfgProductInternal, newProduct: _CfgProductInternal): _CfgOptionInternal[] | null;
 //# sourceMappingURL=SyncGroupsTransaction.d.ts.map