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

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -0,0 +1,18 @@
+import { CfgHistoryManager } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+export const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
+export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, _qsKey = STAGE_PROD_CONF_MESSAGE_KEY, doValidate = true) {
+        super(manager, doValidate);
+        this._qsKey = _qsKey;
+    }
+    getInitialProdConf() {
+        return CfgHistoryManager._currentQsKeyValues().get(this._qsKey);
+    }
+    makeSendData(prodConfAsString, initial) {
+        return {
+            message: this.makeMessage(prodConfAsString, initial),
+            qsKeyValues: new Map([[STAGE_PROD_CONF_MESSAGE_KEY, prodConfAsString]]),
+        };
+    }
+}

package/dist/io/CfgIOManager.d.ts

@@ -0,0 +1,29 @@
+declare type ConfiguraShebang = "c0nf1guraarug1fn0c";
+declare type Listener = (m: unknown) => Promise<void>;
+export declare type CfgIOContainer = {
+    shebang: ConfiguraShebang;
+    messages: {
+        [index: string]: unknown;
+    };
+};
+export declare abstract class CfgIOManager<K extends keyof WindowEventMap, S> {
+    static isIOContainer: (data: any) => data is CfgIOContainer;
+    static hasIOContainerMessageKey: (container: CfgIOContainer, messageKey: string) => boolean;
+    static getMessageFromIOContainer: (container: any, messageKey: string) => unknown;
+    static makeContainer: (messages: {
+        [index: string]: unknown;
+    }) => CfgIOContainer;
+    private _inhibitSend;
+    private _listeners;
+    private _getIndexOfListener;
+    listen: (l: Listener, messageKey: string) => void;
+    stopListen: (l: Listener) => void;
+    private _containerListenerBound;
+    protected _containerListener(event: WindowEventMap[K]): void;
+    send: (messageKey: string, data: S) => void;
+    protected abstract doSend(messageKey: string, data: S): void;
+    protected abstract readonly eventType: K;
+    protected abstract getDataFromEvent(event: WindowEventMap[K]): unknown;
+}
+export {};
+//# sourceMappingURL=CfgIOManager.d.ts.map

package/dist/io/CfgIOManager.js

@@ -0,0 +1,89 @@
+const CONFIGURA_SHEBANG = "c0nf1guraarug1fn0c";
+export class CfgIOManager {
+    constructor() {
+        // A lock to avoid circular write
+        this._inhibitSend = false;
+        this._listeners = [];
+        this._getIndexOfListener = (l) => this._listeners.findIndex((item) => l === item.l);
+        this.listen = (l, messageKey) => {
+            if (this._getIndexOfListener(l) !== -1) {
+                console.warn("Tried to add listener twice");
+                return;
+            }
+            const startListenToWindow = this._listeners.length === 0;
+            this._listeners.push({ l, messageKey });
+            if (startListenToWindow) {
+                window.addEventListener(this.eventType, this._containerListenerBound);
+            }
+        };
+        this.stopListen = (l) => {
+            const i = this._getIndexOfListener(l);
+            if (i === -1) {
+                console.warn("Tried to stopListen on unknown listener");
+                return;
+            }
+            this._listeners.splice(i, 1);
+            if (this._listeners.length === 0) {
+                window.removeEventListener(this.eventType, this._containerListenerBound);
+            }
+        };
+        this._containerListenerBound = this._containerListener.bind(this);
+        this.send = (messageKey, data) => {
+            if (this._inhibitSend) {
+                return;
+            }
+            this.doSend(messageKey, data);
+        };
+    }
+    _containerListener(event) {
+        const data = this.getDataFromEvent(event);
+        if (!CfgIOManager.isIOContainer(data)) {
+            return;
+        }
+        // The 15 or so rows below is one of the cases where I believe building a clever
+        // data structure of so would probably be worse for performance than just looping
+        // as the subscribers are expected to be very few
+        const listeners = this._listeners;
+        const allMessageKeys = listeners.reduce((a, c) => {
+            a.add(c.messageKey);
+            return a;
+        }, new Set());
+        this._inhibitSend = true;
+        const promises = [];
+        for (const messageKey of allMessageKeys) {
+            if (!CfgIOManager.hasIOContainerMessageKey(data, messageKey)) {
+                continue;
+            }
+            const message = CfgIOManager.getMessageFromIOContainer(data, messageKey);
+            for (const item of listeners) {
+                if (item.messageKey !== messageKey) {
+                    continue;
+                }
+                promises.push(item.l(message));
+            }
+        }
+        Promise.all(promises)
+            .then(() => {
+            this._inhibitSend = false;
+        })
+            .catch(() => {
+            this._inhibitSend = false;
+        });
+    }
+}
+CfgIOManager.isIOContainer = (data) => data && data.shebang === CONFIGURA_SHEBANG;
+CfgIOManager.hasIOContainerMessageKey = (container, messageKey) => messageKey in container.messages;
+CfgIOManager.getMessageFromIOContainer = (container, messageKey) => {
+    if (!CfgIOManager.isIOContainer(container)) {
+        throw new Error("The passed data was not a CfgIOContainer. It is to be expected that such data messages can arrive, so please use isIOContainer function to filter them out before calling this.");
+    }
+    if (!CfgIOManager.hasIOContainerMessageKey(container, messageKey)) {
+        throw new Error(`The passed data did not have the messageKey "${messageKey}". You can test for this using hasIOContainerMessageKey function.`);
+    }
+    // It is assumed that if a message arrives with the right subMessageKey it can cast to T
+    return container.messages[messageKey];
+};
+CfgIOManager.makeContainer = (messages) => ({
+    shebang: CONFIGURA_SHEBANG,
+    messages,
+});

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -0,0 +1,31 @@
+import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgProdConfMessage = {
+    version: string;
+    initial: boolean;
+    prodConfAsString: string;
+};
+export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageProdConf";
+export declare const STAGE_PROD_CONF_MESSAGE_VERSION = "1.0";
+export declare type ProdConfCallback = (prodConfAsString: string) => Promise<void>;
+export declare abstract class CfgIOProdConfConnector<K extends keyof WindowEventMap, S, M extends CfgIOManager<K, S>> {
+    protected readonly _ioManager: M;
+    protected readonly _doValidate: boolean;
+    protected _product: CfgProduct | undefined;
+    private _stopListenToMessage;
+    private _stopListenToProdConf;
+    constructor(_ioManager: M, _doValidate: boolean);
+    setProduct: (product: CfgProduct | undefined) => Promise<void>;
+    protected abstract getInitialProdConf(): string | undefined;
+    protected abstract makeSendData(prodConfAsString: string, initial: boolean): S;
+    makeMessage(prodConfAsString: string, initial: boolean): CfgProdConfMessage;
+    makeMessageListener(callback: ProdConfCallback): (message: unknown) => Promise<void>;
+    /**
+     * Register the callback to listen for Product Configuration messages
+     * @returns A function which when called will cancel listening
+     */
+    listenForMessage(callback: ProdConfCallback): () => void;
+    makeProdConfListener(callback: ProdConfCallback): (n: CfgProductChangeNotification) => void;
+    listenForProdConf(product: CfgProduct, callback: ProdConfCallback): () => void;
+}
+//# sourceMappingURL=CfgIOProdConfConnector.d.ts.map

package/dist/io/CfgIOProdConfConnector.js

@@ -0,0 +1,100 @@
+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());
+    });
+};
+export const STAGE_PROD_CONF_MESSAGE_KEY = "stageProdConf";
+export const STAGE_PROD_CONF_MESSAGE_VERSION = "1.0";
+export class CfgIOProdConfConnector {
+    constructor(_ioManager, _doValidate) {
+        this._ioManager = _ioManager;
+        this._doValidate = _doValidate;
+        this._stopListenToMessage = undefined;
+        this._stopListenToProdConf = undefined;
+        this.setProduct = (product) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const currentProduct = this._product;
+            const newProduct = product;
+            this._product = newProduct;
+            // If same product don't do anything at all
+            if (currentProduct !== undefined &&
+                newProduct !== undefined &&
+                currentProduct.isBackedBySame(newProduct)) {
+                return;
+            }
+            if (currentProduct !== undefined) {
+                (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
+                (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
+            }
+            if (newProduct === undefined) {
+                return;
+            }
+            if (currentProduct === undefined) {
+                const initialProdConf = this.getInitialProdConf();
+                if (initialProdConf !== undefined) {
+                    yield newProduct.setFromApiSelectionString(initialProdConf, this._doValidate);
+                }
+            }
+            else {
+                this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, this.makeSendData(newProduct.getApiSelectionAsString(), true));
+            }
+            this._stopListenToMessage = this.listenForMessage((prodConfAsString) => __awaiter(this, void 0, void 0, function* () {
+                if (prodConfAsString === newProduct.getApiSelectionAsString()) {
+                    return;
+                }
+                yield newProduct.setFromApiSelectionString(prodConfAsString, this._doValidate);
+            }));
+            this._stopListenToProdConf = this.listenForProdConf(newProduct, (prodConfAsString) => __awaiter(this, void 0, void 0, function* () {
+                this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, this.makeSendData(prodConfAsString, false));
+            }));
+        });
+    }
+    makeMessage(prodConfAsString, initial) {
+        return {
+            version: STAGE_PROD_CONF_MESSAGE_VERSION,
+            initial,
+            prodConfAsString,
+        };
+    }
+    makeMessageListener(callback) {
+        return (message) => __awaiter(this, void 0, void 0, function* () {
+            const { version, prodConfAsString } = message;
+            if (version !== "1.0") {
+                console.error(`The a message was passed with an unsupported version "${version}". Currently only ${STAGE_PROD_CONF_MESSAGE_VERSION} is supported.`);
+                return;
+            }
+            yield callback(prodConfAsString);
+        });
+    }
+    /**
+     * Register the callback to listen for Product Configuration messages
+     * @returns A function which when called will cancel listening
+     */
+    listenForMessage(callback) {
+        const ioManager = this._ioManager;
+        const listener = this.makeMessageListener(callback);
+        ioManager.listen(listener, STAGE_PROD_CONF_MESSAGE_KEY);
+        return () => {
+            ioManager.stopListen(listener);
+        };
+    }
+    makeProdConfListener(callback) {
+        return (n) => {
+            if (!n.committed) {
+                return;
+            }
+            callback(n.freshRef.getApiSelectionAsString());
+        };
+    }
+    listenForProdConf(product, callback) {
+        const listener = this.makeProdConfListener(callback);
+        product.listenForChange(listener);
+        return () => {
+            product.stopListenForChange(listener);
+        };
+    }
+}

package/dist/io/CfgWindowMessageManager.d.ts

@@ -0,0 +1,13 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgWindowMessageManagerSendData = unknown;
+export declare class CfgWindowMessageManager extends CfgIOManager<"message", CfgWindowMessageManagerSendData> {
+    private readonly _remoteEnds;
+    private readonly _targetOrigin;
+    private readonly _acceptableMessageOrigin?;
+    constructor(_remoteEnds: Window[], _targetOrigin?: string, _acceptableMessageOrigin?: string | undefined);
+    protected doSend(messageKey: string, data: unknown): void;
+    protected _containerListener(event: MessageEvent<any>): void;
+    protected readonly eventType = "message";
+    protected getDataFromEvent(event: MessageEvent<any>): unknown;
+}
+//# sourceMappingURL=CfgWindowMessageManager.d.ts.map

package/dist/io/CfgWindowMessageManager.js

@@ -0,0 +1,28 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export class CfgWindowMessageManager extends CfgIOManager {
+    constructor(_remoteEnds, _targetOrigin = "*", _acceptableMessageOrigin) {
+        super();
+        this._remoteEnds = _remoteEnds;
+        this._targetOrigin = _targetOrigin;
+        this._acceptableMessageOrigin = _acceptableMessageOrigin;
+        this.eventType = "message";
+    }
+    doSend(messageKey, data) {
+        const container = CfgIOManager.makeContainer({
+            [messageKey]: data,
+        });
+        for (const remoteEnd of this._remoteEnds) {
+            remoteEnd.postMessage(container, this._targetOrigin);
+        }
+    }
+    _containerListener(event) {
+        if (this._acceptableMessageOrigin !== undefined &&
+            event.origin !== this._acceptableMessageOrigin) {
+            return;
+        }
+        super._containerListener(event);
+    }
+    getDataFromEvent(event) {
+        return event.data;
+    }
+}

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

@@ -0,0 +1,13 @@
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+import { CfgWindowMessageManager, CfgWindowMessageManagerSendData } from "./CfgWindowMessageManager.js";
+/**
+ * Instantiating the class will expose your product to:
+ * - Listen for configuration changes posted to this window
+ * - Send configuration changes using sendMessage
+ */
+export declare class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector<"message", CfgWindowMessageManagerSendData, CfgWindowMessageManager> {
+    constructor(manager: CfgWindowMessageManager, doValidate?: boolean);
+    protected getInitialProdConf(): string | undefined;
+    protected makeSendData(prodConfAsString: string, initial: boolean): CfgWindowMessageManagerSendData;
+}
+//# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -0,0 +1,17 @@
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+/**
+ * Instantiating the class will expose your product to:
+ * - Listen for configuration changes posted to this window
+ * - Send configuration changes using sendMessage
+ */
+export class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, doValidate = true) {
+        super(manager, doValidate);
+    }
+    getInitialProdConf() {
+        return undefined;
+    }
+    makeSendData(prodConfAsString, initial) {
+        return this.makeMessage(prodConfAsString, initial);
+    }
+}

package/dist/productConfiguration/CfgFeature.d.ts

@@ -1,6 +1,6 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { Feature, SelectedOption, SyncGroup } from "../CatalogueAPI.js";
-import { CfgPath, CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
+import { Feature, SelectedOption } from "../CatalogueAPI.js";
+import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { CfgOption, ProductConfigurationBubbleMode, _CfgOptionInternal } from "./CfgOption.js";
 import { _CfgProductConfigurationInternal } from "./CfgProductConfiguration.js";
@@ -49,7 +49,6 @@ export declare class _CfgFeatureInternal {
     get isUseNumericValue(): boolean;
     get numericValue(): number | undefined;
     setNumericValue: (val: number) => Promise<boolean>;
-    get syncGroup(): SyncGroup | undefined;
     get description(): string;
     /**
      * The MeasureParam class is re-used for different purposes. In Features it is used
@@ -96,8 +95,6 @@ export declare class _CfgFeatureInternal {
     setApiSelection: (apiOptionSelectionMap: {
         [index: string]: SelectedOption;
     } | undefined) => Promise<boolean>;
-    get path(): CfgPath;
-    getFromPath(path: CfgPath): _CfgFeatureInternal | _CfgOptionInternal;
     /** Pushes to refresh stretch. Does not cause validation. */
     pushStretch: () => Promise<boolean>;
     structureCompare: (other: _CfgFeatureInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;

package/dist/productConfiguration/CfgFeature.js

@@ -11,7 +11,6 @@ import { compareArrays, convertLength, count, Observable, someMatch, toLengthUni
 import { CfgProduct } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { CfgMtrlApplicationSource } from "../material/CfgMtrlApplicationSource.js";
-import { wrapWithCache } from "../productLoader.js";
 import { CfgOption, ProductConfigurationBubbleMode } from "./CfgOption.js";
 import { _CfgProductConfigurationInternal } from "./CfgProductConfiguration.js";
 import { getMtrlPreview } from "./utilitiesProductConfiguration.js";
@@ -87,9 +86,9 @@ export class _CfgFeatureInternal {
             if (bubbleMode === ProductConfigurationBubbleMode.Stop) {
                 return;
             }
-            const parent = this.parent;
             const freshRef = CfgFeature._makeNewRefFrom(this);
             this.changeObservable.notifyAll({ freshRef });
+            const parent = this.parent;
             if (parent !== undefined) {
                 yield parent._childHasChanged(freshRef, bubbleMode === ProductConfigurationBubbleMode.OneLevel
                     ? ProductConfigurationBubbleMode.Stop
@@ -307,15 +306,6 @@ export class _CfgFeatureInternal {
          * Using a validate bubbleMode will cause validation calls to the server.
          */
         this.selectOption = (optionInternal, on, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
-            if (bubbleMode ===
-                ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups) {
-                const product = this.rootProduct;
-                const syncGroupHandler = product.syncGroupHandler;
-                if (syncGroupHandler === undefined) {
-                    throw new Error(`No sync group handler when bubble mode ${ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups}`);
-                }
-                return yield syncGroupHandler.selectOption(product, optionInternal.path, on, wrapWithCache(product._productLoaderRaw));
-            }
             if (!on) {
                 if (this.selectionType === SelectionType.Group) {
                     throw new Error(`Multiple features are always selected and are not user selectable. Feature key: "${this.key}".`);
@@ -367,18 +357,11 @@ export class _CfgFeatureInternal {
             if (isAllOptionsAffectedByAnySelection) {
                 this._freshRefAllOptions();
             }
-            let nextLevelBubbleMode = bubbleMode;
-            if (!on) {
-                // If this was a deselect action we shall not bubble selected, that is, we shall not
-                // select the ancestors if this action was deselect.
-                if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected) {
-                    nextLevelBubbleMode = ProductConfigurationBubbleMode.Validate;
-                }
-                else if (bubbleMode === ProductConfigurationBubbleMode.BubbleSelected) {
-                    nextLevelBubbleMode = ProductConfigurationBubbleMode.ToRoot;
-                }
-            }
-            yield this._notifyAllOfChange(nextLevelBubbleMode);
+            // If this was a deselect action we shall not bubble selected, that is, we shall not
+            // select the ancestors if this action was deselect.
+            yield this._notifyAllOfChange(!on && bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected
+                ? ProductConfigurationBubbleMode.Validate
+                : bubbleMode);
             return isActualChange;
         });
         this.isSelected = (option) => this.selectionType === SelectionType.Group ||
@@ -429,9 +412,6 @@ export class _CfgFeatureInternal {
         }
         return value;
     }
-    get syncGroup() {
-        return this.rawFeature.syncGroup;
-    }
     get description() {
         return this.rawFeature.description;
     }
@@ -502,23 +482,6 @@ export class _CfgFeatureInternal {
         }
         return this._options;
     }
-    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 option = this.options.find((o) => o.code === s);
-                if (option === undefined) {
-                    throw new Error(`Option not found ${s}, ${path.join(", ")}`);
-                }
-                return option._internal.getFromPath(path);
-        }
-    }
     /**
      * Make fresh references to all options on this feature.
      * Also includes currently selected options.
@@ -568,7 +531,7 @@ export class CfgFeature {
          * Calling this will cause a validation call to the server.
          */
         this.selectOption = (option, on) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._internal.selectOption(option._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups);
+            return yield this._internal.selectOption(option._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelected);
         });
         this.isSelected = (option) => this._internal.isSelected(option._internal);
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);

package/dist/productConfiguration/CfgOption.d.ts

@@ -1,6 +1,6 @@
 import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
 import { Feature, Option, SelectedOption } from "../CatalogueAPI.js";
-import { CfgPath, CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
+import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { NumericValuesSelection } from "../utilitiesNumericValues.js";
 import { CfgFeature, _CfgFeatureInternal } from "./CfgFeature.js";
@@ -9,10 +9,6 @@ export declare type OptionChangeNotification = {
     freshRef: CfgOption;
 };
 export declare enum ProductConfigurationBubbleMode {
-    /**
-     * If this is select it will turns on all ancestors all the way up.
-     */
-    BubbleSelected = "BubbleSelected",
     /**
      * Bubble to the closest CfgProduct, let it revalidate, then that will continue
      * the bubble after validate.
@@ -24,11 +20,6 @@ export declare enum ProductConfigurationBubbleMode {
      * So with this mode it is possible to select an option where its parents are not selected.
      */
     ValidateAndBubbleSelected = "ValidateAndBubbleSelected",
-    /**
-     * Like ValidateAndBubbleSelected, but SyncGroups are applied after
-     * ValidateAndBubbleSelected has been done
-     */
-    ValidateAndBubbleSelectedAndApplySyncGroups = "ValidateAndBubbleSelectedAndApplySyncGroups",
     /**
      * Stop bubbling
      * This mode supports internal functionality and is not expected to be used by integrators.
@@ -90,8 +81,6 @@ export declare class _CfgOptionInternal {
     _childHasChanged: (freshRef: CfgFeature, bubbleMode: ProductConfigurationBubbleMode) => Promise<void>;
     getApiSelection: () => SelectedOption;
     setApiSelection: (apiOptionSelection: SelectedOption | undefined) => Promise<boolean>;
-    get path(): CfgPath;
-    getFromPath(path: CfgPath): _CfgFeatureInternal | _CfgOptionInternal;
     structureCompare: (other: _CfgOptionInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
     tryMatchSelection: (other: CfgOption, descriptionMatch?: boolean) => Promise<boolean>;
     keyMatch: (other: _CfgOptionInternal, descriptionMatch?: boolean) => boolean;

package/dist/productConfiguration/CfgOption.js

@@ -17,10 +17,6 @@ import { CfgFeature, SelectionType } from "./CfgFeature.js";
 import { getMtrlPreview, syncCfgFeatures } from "./utilitiesProductConfiguration.js";
 export var ProductConfigurationBubbleMode;
 (function (ProductConfigurationBubbleMode) {
-    /**
-     * If this is select it will turns on all ancestors all the way up.
-     */
-    ProductConfigurationBubbleMode["BubbleSelected"] = "BubbleSelected";
     /**
      * Bubble to the closest CfgProduct, let it revalidate, then that will continue
      * the bubble after validate.
@@ -32,11 +28,6 @@ export var ProductConfigurationBubbleMode;
      * 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
-     */
-    ProductConfigurationBubbleMode["ValidateAndBubbleSelectedAndApplySyncGroups"] = "ValidateAndBubbleSelectedAndApplySyncGroups";
     /**
      * Stop bubbling
      * This mode supports internal functionality and is not expected to be used by integrators.
@@ -102,8 +93,7 @@ export class _CfgOptionInternal {
             features[i] = freshRef;
             // In CfgOption we let stop bubble slip through. This is because CfgOption is sort of
             // a semi level. Like Feature + Option together constitutes one level.
-            if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected ||
-                bubbleMode === ProductConfigurationBubbleMode.BubbleSelected) {
+            if (bubbleMode === ProductConfigurationBubbleMode.ValidateAndBubbleSelected) {
                 // selectOption takes care of the bubble
                 yield this.parent.selectOption(this, true, bubbleMode);
             }
@@ -243,7 +233,7 @@ export class _CfgOptionInternal {
             }
             else {
                 if (change) {
-                    yield this.parent._childHasChanged(this, ProductConfigurationBubbleMode.OneLevel);
+                    yield this.parent._childHasChanged(this, ProductConfigurationBubbleMode.Stop);
                 }
             }
             return change;
@@ -310,23 +300,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++) {
@@ -353,7 +326,7 @@ export class CfgOption {
          * Calling this will cause a validation call to the server.
          */
         this.setSelected = (on) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._internal.parent.selectOption(this._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelectedAndApplySyncGroups);
+            return yield this._internal.parent.selectOption(this._internal, on, ProductConfigurationBubbleMode.ValidateAndBubbleSelected);
         });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -1,10 +1,11 @@
 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;
+    committed: boolean;
 };
 export declare type LengthValue = {
     length: number;
@@ -43,8 +44,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
@@ -54,7 +53,7 @@ export declare class _CfgProductConfigurationInternal {
     /** Only selected features. */
     _getFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
     populateFeatures: (rootFeatureRefs: FeatureRef[]) => void;
-    setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit, doNotify?: boolean) => Promise<boolean>;
+    setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit) => Promise<boolean>;
 }
 export declare class CfgProductConfiguration {
     readonly _internal: _CfgProductConfigurationInternal;