@configura/web-api 1.6.1-alpha.0 → 1.6.1-alpha.4

package/dist/productConfiguration/CfgOption.js

@@ -22,19 +22,19 @@ export var ProductConfigurationBubbleMode;
      */
     ProductConfigurationBubbleMode["BubbleSelected"] = "BubbleSelected";
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate.
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate.
      */
     ProductConfigurationBubbleMode["Validate"] = "Validate";
     /**
-     * Bubble to the closest CfgProduct, let it revalidate, then that will continue
-     * the bubble after validate. If this is select it will turns on all ancestors all the way up.
+     * Bubble to the closest CfgProduct, let it revalidate, then that will continue the bubble
+     * after validate. If this is select it will turn on all ancestors all the way up.
      * So with this mode it is possible to select an option where its parents are not selected.
      */
     ProductConfigurationBubbleMode["ValidateAndBubbleSelected"] = "ValidateAndBubbleSelected";
     /**
-     * Like ValidateAndBubbleSelected, but SyncGroups are applied after
-     * ValidateAndBubbleSelected has been done
+     * Like ValidateAndBubbleSelected, but SyncGroups are applied after ValidateAndBubbleSelected
+     * has been done
      */
     ProductConfigurationBubbleMode["ValidateAndBubbleSelectedAndApplySyncGroups"] = "ValidateAndBubbleSelectedAndApplySyncGroups";
     /**
@@ -75,10 +75,9 @@ function doesChildrenShareOptionsCode(features) {
     return false;
 }
 /**
- * This class is meant to only be used through CfgOption. It should
- * never be instantiated on its own. Normally the internal state of this class
- * should never be directly modified. CfgOption is the class that
- * should be used and interacted with.
+ * This class is only meant to be used through CfgOption. It should never be instantiated on its
+ * own. Normally the internal state of this class should never be directly modified. CfgOption is
+ * the class that should be used and interacted with.
  */
 export class _CfgOptionInternal {
     constructor(rawOption, allRawFeatures, siblingHasDuplicateDescription, parent, parentConfiguration, parentProduct, rootProduct) {
@@ -180,9 +179,8 @@ export class _CfgOptionInternal {
             agg.push(...feature._internal._getFeaturesWithCode(code));
             return agg;
         }, []);
-        // Description based key helps when switching between
-        // products with similar feature-options tree and trying
-        // to retain made selection
+        // Description based key helps when switching between products with similar feature-options
+        // tree and trying to retain made selection.
         this.key =
             this.description +
                 (this.description === "" || siblingHasDuplicateDescription ? this.code : "");
@@ -229,9 +227,9 @@ export class _CfgOptionInternal {
                     this._numericValue = val;
                     change = true;
                 }
-                // It could be that even though our value did not change some sibling value did, and this
-                // could make it needed to bubble later. Maybe. A bit uncertain about why I did not put
-                // this in the if-statement above //Linus
+                // It could be that even though our value did not change some sibling value did, and
+                // this could make it needed to bubble later. Maybe. A bit uncertain about why I did
+                // not put this in the if-statement above //Linus
                 if (yield this.parent.pushStretch()) {
                     change = true;
                 }
@@ -258,6 +256,20 @@ export class _CfgOptionInternal {
     get selected() {
         return this.parent.isSelected(this);
     }
+    get selectedChangeInProgress() {
+        const syncGroupHandler = this.rootProduct.syncGroupHandler;
+        if (syncGroupHandler === undefined) {
+            return false;
+        }
+        const inProgressOption = syncGroupHandler.pending;
+        if (inProgressOption === this) {
+            return true;
+        }
+        if (!(this.selected && this.parent.selectionType === SelectionType.SelectOne)) {
+            return false;
+        }
+        return this.parent.options.some((o) => o._internal === inProgressOption);
+    }
     get ancestorsSelected() {
         return this.selected && this.parent.ancestorsSelected;
     }
@@ -310,23 +322,6 @@ export class _CfgOptionInternal {
         }
         return this._features;
     }
-    get path() {
-        return [...this.parent.path, this.code];
-    }
-    getFromPath(path) {
-        path = path.slice();
-        const s = path.shift();
-        switch (s) {
-            case undefined:
-                return this;
-            default:
-                const feature = this.features.find((o) => o.code === s);
-                if (feature === undefined) {
-                    throw new Error(`Feature not found ${s}, ${path.join(", ")}`);
-                }
-                return feature._internal.getFromPath(path);
-        }
-    }
     _freshRefDescendants() {
         const features = this._features || [];
         for (let i = 0; i < features.length; i++) {
@@ -347,7 +342,7 @@ export class CfgOption {
         this.isBackedBySame = (other) => this._internal === other._internal;
         this.setNumericValue = (val, doSelectOption) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setNumericValue(val, doSelectOption); });
         this.isAllowedNumericValue = (val) => this._internal.isAllowedNumericValue(val);
-        /*
+        /**
          * Selects this Option.
          * Only Options belonging to Features that are "select many" can be deselected.
          * Calling this will cause a validation call to the server.
@@ -402,6 +397,16 @@ export class CfgOption {
     get selected() {
         return this._internal.selected;
     }
+    /**
+     * Selection state is in progress to be changed. This can be used in GUI
+     * to display the state as transitioning, or as already changed.
+     * If selectedChangeInProgress and:
+     * selected is true, it means that this is about to get unselected
+     * selected is false, it means that this is about to get selected
+     */
+    get selectedChangeInProgress() {
+        return this._internal.selectedChangeInProgress;
+    }
     /** Are all ancestors up to the CfgProductConfiguration selected? Includes self. */
     get ancestorsSelected() {
         return this._internal.ancestorsSelected;

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -1,8 +1,8 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
 import { Feature, FeatureRef, SelectedOption } from "../CatalogueAPI.js";
-import { CfgPath, CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
+import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgFeature, _CfgFeatureInternal } from "./CfgFeature.js";
-import { ProductConfigurationBubbleMode, _CfgOptionInternal } from "./CfgOption.js";
+import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 export declare type ProductConfigurationChangeNotification = {
     freshRef: CfgProductConfiguration;
 };
@@ -43,8 +43,6 @@ export declare class _CfgProductConfigurationInternal {
      * outside we want notifications to bubble all the way to the root.
      */
     setApiSelection: (selectedOptions: SelectedOption[], bubbleToRoot: boolean) => Promise<boolean>;
-    get path(): CfgPath;
-    getFromPath(path: CfgPath): _CfgProductConfigurationInternal | _CfgFeatureInternal | _CfgOptionInternal;
     structureCompare: (other: _CfgProductConfigurationInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
     /**
      * When used internally the notifications are taken care off by the caller, but if set from

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -215,23 +215,6 @@ export class _CfgProductConfigurationInternal {
             features[i] = CfgFeature._makeNewRefFrom(featureInternal);
         }
     }
-    get path() {
-        return [...this.parentProduct.path, "c"];
-    }
-    getFromPath(path) {
-        path = path.slice();
-        const s = path.shift();
-        switch (s) {
-            case undefined:
-                return this;
-            default:
-                const feature = this.features.find((f) => f.code === s);
-                if (feature === undefined) {
-                    throw new Error(`Feature not found ${s}, ${path.join(", ")}`);
-                }
-                return feature._internal.getFromPath(path);
-        }
-    }
 }
 export class CfgProductConfiguration {
     /**

package/dist/productConfiguration/filters.d.ts

@@ -12,5 +12,5 @@ export declare function applyProductRefFilters(filters: Filters<ProductRefParams
  * @param prdRefsFilter Products not in this array are removed
  * @param showEmpty Shall empty levels be shown?
  */
-export declare function cloneFilterSortLevels(levels: Level[], prdRefsFilter: ProductRef[], showEmpty: boolean): Level[] | undefined;
+export declare function cloneFilterSortLevels(levels: Level[], prdRefsFilter: ProductRef[], showEmpty: boolean, doSort?: boolean): Level[] | undefined;
 //# sourceMappingURL=filters.d.ts.map

package/dist/productConfiguration/filters.js

@@ -34,13 +34,13 @@ export function applyProductRefFilters(filters, productRefs) {
  * @param prdRefsFilter Products not in this array are removed
  * @param showEmpty Shall empty levels be shown?
  */
-export function cloneFilterSortLevels(levels, prdRefsFilter, showEmpty) {
+export function cloneFilterSortLevels(levels, prdRefsFilter, showEmpty, doSort = true) {
     const newLevels = [];
     for (const level of levels) {
         // recursively fetch the next levels
         let nextLevels;
         if (level.lvls !== undefined) {
-            nextLevels = cloneFilterSortLevels(level.lvls, prdRefsFilter, showEmpty);
+            nextLevels = cloneFilterSortLevels(level.lvls, prdRefsFilter, showEmpty, doSort);
         }
         // filter out products
         let newPrdRefs;
@@ -63,5 +63,8 @@ export function cloneFilterSortLevels(levels, prdRefsFilter, showEmpty) {
             newLevels.push(newLevel);
         }
     }
-    return newLevels.sort((l1, l2) => l1.description.toLocaleLowerCase().localeCompare(l2.description.toLocaleLowerCase()));
+    if (doSort) {
+        return newLevels.sort((l1, l2) => l1.description.toLocaleLowerCase().localeCompare(l2.description.toLocaleLowerCase()));
+    }
+    return newLevels;
 }

package/dist/syncGroups/SyncGroupsApplier.js

@@ -88,7 +88,7 @@ class SyncStateOnto {
                 // All settled, continue to pullPhase
                 return yield OntoSyncState.rootProduct(transaction);
             }
-            if (transaction.isAborted) {
+            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.
@@ -106,7 +106,7 @@ class SyncStateOnto {
             // could accumulate and what is cause and effect be hard to know.
             if (!revalidationResults.every((r) => r.requestDidValidate) ||
                 revalidationResults.every((r) => r.wasAborted)) {
-                transaction.abort();
+                transaction.close();
                 return false;
             }
             // Apply over again, to settle deeper down. Our theory is that the front of
@@ -412,17 +412,18 @@ class OntoSyncState {
         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
+        // featureDidJustComeIntoScope, in CET there is a feature that if a feature appears which
+        // can not be set to the current sync group value, then it will set in the opposite
+        // direction. Like if the sync group was empty. To avoid bouncing back and forth we will
+        // need to enforce that a sync group can only be updated once per transaction
         if (!(activeSelectionForce ||
             currentSyncGroupOptionCode === undefined ||
             (featureDidJustComeIntoScope &&
                 feature.options.every((o) => currentSyncGroupOptionCode !== o.code)))) {
             return false;
         }
-        syncState.logDebug();
+        // TODO: Remove
+        //syncState.logDebug();
         transaction.addSyncGroupAffectedForSelectOne(syncCode);
         syncState.setForSelectOne(syncCode, optionCode);
         return true;

package/dist/syncGroups/SyncGroupsApplyMode.d.ts

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

package/dist/syncGroups/SyncGroupsApplyMode.js

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

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -1,4 +1,6 @@
-import { CfgPath, _CfgProductInternal } from "../CfgProduct.js";
+import { AggregatedLoadingObservable } from "@configura/web-utilities";
+import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
 import { ProductLoader } from "../productLoader.js";
 import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
 import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
@@ -11,9 +13,13 @@ export declare type OptionCode = string;
 export declare class SyncGroupsHandler {
     private _syncState;
     readonly updateMode: SyncGroupsApplyMode;
+    private readonly _loadingObservable;
     private _currentTransaction;
-    static make(updateMode?: SyncGroupsApplyMode): SyncGroupsHandler;
+    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable): SyncGroupsHandler;
     private constructor();
+    /**
+     * Please note that clones will use the same loadingObservable as their source
+     */
     clone(): SyncGroupsHandler;
     /**
      * Used to initially apply the sync state onto a new product so that it is "in sync"
@@ -23,8 +29,12 @@ export declare class SyncGroupsHandler {
      * Used when an Option is selected or deselected to apply all consequences of the sync groups.
      * Can cause multiple extra validation calls to the server.
      */
-    selectOption(product: _CfgProductInternal, optionPath: CfgPath, on: boolean, productLoader: ProductLoader): Promise<boolean>;
+    selectOption(product: _CfgProductInternal, option: _CfgOptionInternal, on: boolean, productLoader: ProductLoader): Promise<boolean>;
+    private _pending;
+    private setPending;
+    get pending(): _CfgOptionInternal | undefined;
     newTransaction(product: _CfgProductInternal, productLoader: ProductLoader, assumeNoStartProductState: boolean): Promise<SyncGroupsTransaction>;
+    private closeTransaction;
     applyTransaction(transaction: SyncGroupsTransaction): Promise<void>;
 }
 //# sourceMappingURL=SyncGroupsHandler.d.ts.map