@configura/web-api 1.3.0-alpha.1 → 1.3.0-alpha.5

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -1,4 +1,4 @@
-import { Observable, SingleArgCallback } from "@configura/web-utilities";
+import { LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
 import { Feature, FeatureRef, SelectedOption } from "../CatalogueAPI.js";
 import { CfgProduct, _CfgProductInternal } from "../CfgProduct.js";
 import { CfgFeature, _CfgFeatureInternal } from "./CfgFeature.js";
@@ -6,44 +6,114 @@ import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 export declare type ProductConfigurationChangeNotification = {
     freshRef: CfgProductConfiguration;
 };
+export declare type LengthValue = {
+    length: number;
+    unit: LengthUnit;
+};
+export declare type StretchMap = Map<string, {
+    def: LengthValue | undefined;
+    current: LengthValue;
+}>;
+/**
+ * This class is meant to only be used through CfgProductConfiguration. It should never be
+ * instantiated on its own. Normally the internal state of this class should never be directly
+ * modified. CfgProductConfiguration is the class that should be used and interacted with.
+ */
 export declare class _CfgProductConfigurationInternal {
     readonly allRawFeatures: Feature[];
     readonly parentProduct: _CfgProductInternal;
     readonly rootProduct: _CfgProductInternal;
-    static _makeUninitialized: (rootFeatureRefs: FeatureRef[], allRawFeatures: Feature[], parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal) => _CfgProductConfigurationInternal;
+    static _makeUninitialized(rootFeatureRefs: FeatureRef[], allRawFeatures: Feature[], // Flat packed. All the features that can appear anyplace in the selection tree.
+    parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): _CfgProductConfigurationInternal;
     private constructor();
     readonly key = "~";
     private _rootFeatureRefs;
     private _features;
+    readonly stretchReferenceLengthsByMeasureParamCode: StretchMap;
     readonly changeObservable: Observable<ProductConfigurationChangeNotification>;
     get rootFeatureRefs(): FeatureRef[];
     get features(): CfgFeature[];
     private _notifyAllOfChange;
     _freshRefDescendants(): void;
+    /** Called by child to tell its parent that it has changed. */
     _childHasChanged: (freshRef: CfgFeature, bubbleMode: ProductConfigurationBubbleMode) => Promise<void>;
     getApiSelection: () => SelectedOption[];
+    /**
+     * When used internally the notifications are taken care off by the caller, but if set from
+     * outside we want notifications to bubble all the way to the root.
+     */
     setApiSelection: (selectedOptions: SelectedOption[], bubbleToRoot: boolean) => Promise<boolean>;
     structureCompare: (other: _CfgProductConfigurationInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
+    /**
+     * When used internally the notifications are taken care off by the caller, but if set from
+     * outside we want notifications to bubble all the way to the root.
+     */
     tryMatchSelection: (other: _CfgProductConfigurationInternal, descriptionMatch: boolean | undefined, validate: boolean) => Promise<boolean>;
+    /** Only selected features. */
     _getFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
     populateFeatures: (rootFeatureRefs: FeatureRef[]) => void;
+    setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit, doNotify?: boolean) => Promise<boolean>;
 }
 export declare class CfgProductConfiguration {
     readonly _internal: _CfgProductConfigurationInternal;
-    static make: (initSuccess: (c: CfgProductConfiguration) => void, initFail: (error: Error) => void, rootFeatureRefs: FeatureRef[], allRawFeatures: Feature[], apiSelection: SelectedOption[], parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal) => CfgProductConfiguration;
-    static _makeNewRefFrom: (internal: _CfgProductConfigurationInternal) => CfgProductConfiguration;
+    /**
+     * This method is semi-async. It will immediately give you a reference to the created
+     * CfgProductConfiguration, but is not properly initialized until the initDone-callback
+     * has been called.
+     */
+    static make(initSuccess: (c: CfgProductConfiguration) => void, initFail: (error: Error) => void, rootFeatureRefs: FeatureRef[], allRawFeatures: Feature[], // Flat packed. All the features that can appear anyplace in the selection tree.
+    apiSelection: SelectedOption[], parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgProductConfiguration;
+    /**
+     * Makes an object wrapping the passed object. This is not a clone method, it is a method to
+     * make a new outer reference. Like a shallow copy.
+     *
+     * We use this to help frameworks that are built around using equals to detect change.
+     */
+    static _makeNewRefFrom(internal: _CfgProductConfigurationInternal): CfgProductConfiguration;
+    /**
+     * Private constructor and make-method because make new ref requires the constructor to take an
+     * internal and we don't want those who instantiate CfgProductConfiguration to have to be aware
+     * of the internal.
+     */
     private constructor();
     isBackedBySame: (other: CfgProductConfiguration) => boolean;
     get parentProduct(): CfgProduct;
     get rootProduct(): CfgProduct;
     get key(): string;
+    /**
+     * Every (unprocessed) feature which might be used in this product. This is constant for a
+     * product load. What features are actually used is controlled by rootFeatureRefs and what
+     * options are selected.
+     */
     get allRawFeatures(): Feature[];
+    /** What features are used in the root of this. This can change with new validate calls. */
     get rootFeatureRefs(): FeatureRef[];
+    /** The root features at the root of the selection tree. */
     get features(): CfgFeature[];
     structureCompare: (other: CfgProductConfiguration, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
+    /**
+     * This method will try to match the selection from another product configuration
+     * This method does not propagate its selections.
+     * This method will cause validation calls.
+     */
     tryMatchSelection: (other: CfgProductConfiguration, descriptionMatch?: boolean) => Promise<boolean>;
     getApiSelection: () => SelectedOption[];
+    /**
+     * This method does not propagate its selections.
+     * This method will not cause validation calls. Data is assumed to already be validated.
+     */
     setApiSelection: (selectedOptions: SelectedOption[]) => Promise<boolean>;
+    /**
+     * Set how stretched a certain measure should be measureParamCode is the measure to be
+     * stretched referenceLength is a value relative to the initial length of the measure. If the
+     * stretch drawn up in Model Lab was from the start let's say 2.4 units from start point to end
+     * point a reference value of 4.8 would stretch the start point to end point to double length.
+     * This however does not stop things from extending outside start point to end point. So the
+     * actual perceived length after stretching might have little to do with the referenceLength.
+     * Undefined as referenceLength will clear, that is, make the stretched thing revert to its
+     * default state.
+     */
+    setStretchReferenceLength: (measureParamCode: string, referenceLength: number, unit: LengthUnit) => Promise<boolean>;
     listenForChange: (l: SingleArgCallback<ProductConfigurationChangeNotification>) => void;
     stopListenForChange: (l: SingleArgCallback<ProductConfigurationChangeNotification>) => void;
     stopAllListenForChange: () => void;

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -7,15 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { compareArrays, count, Observable, toError, } from "@configura/web-utilities";
+import { compareArrays, count, isLengthUnit, Observable, toError, toLengthUnit, } from "@configura/web-utilities";
 import { CfgProduct } from "../CfgProduct.js";
 import { CfgFeature } from "./CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 import { syncCfgFeatures } from "./utilitiesProductConfiguration.js";
-/// This class is meant to only be used through CfgProductConfiguration. It should
-/// never be instantiated on its own. Normally the internal state of this class
-/// should never be directly modified. CfgProductConfiguration is the class that
-/// should be used and interacted with.
+/**
+ * This class is meant to only be used through CfgProductConfiguration. It should never be
+ * instantiated on its own. Normally the internal state of this class should never be directly
+ * modified. CfgProductConfiguration is the class that should be used and interacted with.
+ */
 export class _CfgProductConfigurationInternal {
     constructor(allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
     parentProduct, rootProduct) {
@@ -42,7 +43,7 @@ export class _CfgProductConfigurationInternal {
                 ? ProductConfigurationBubbleMode.Stop
                 : bubbleMode);
         });
-        /// Called by child to tell its parent that it has changed.
+        /** Called by child to tell its parent that it has changed. */
         this._childHasChanged = (freshRef, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
             const features = this._features;
             const i = features.findIndex((a) => a.isBackedBySame(freshRef));
@@ -55,8 +56,10 @@ export class _CfgProductConfigurationInternal {
         this.getApiSelection = () => this._features.map((f) => {
             return { code: "!~!", next: f._internal.getApiSelection() };
         });
-        /// When used internally the notifications are taken care off by the caller,
-        /// but if set from outside we want notifications to bubble all the way to the root
+        /**
+         * When used internally the notifications are taken care off by the caller, but if set from
+         * outside we want notifications to bubble all the way to the root.
+         */
         this.setApiSelection = (selectedOptions, bubbleToRoot) => __awaiter(this, void 0, void 0, function* () {
             const featuresLength = this._features.length;
             const selectedOptionsLength = selectedOptions.length;
@@ -72,8 +75,10 @@ export class _CfgProductConfigurationInternal {
             return change;
         });
         this.structureCompare = (other, strictOrder = true, descriptionMatch = false) => compareArrays(this.features, other.features, (l, r) => l._internal.structureCompare(r._internal, strictOrder, descriptionMatch), strictOrder);
-        /// When used internally the notifications are taken care off by the caller,
-        /// but if set from outside we want notifications to bubble all the way to the root
+        /**
+         * When used internally the notifications are taken care off by the caller, but if set from
+         * outside we want notifications to bubble all the way to the root.
+         */
         this.tryMatchSelection = (other, descriptionMatch = false, // Match on case insensitive description, not code
         validate) => __awaiter(this, void 0, void 0, function* () {
             const thisFeatures = this.features;
@@ -101,15 +106,99 @@ export class _CfgProductConfigurationInternal {
             }
             return change;
         });
-        /// Only selected features
+        /** Only selected features. */
         this._getFeaturesWithCode = (code) => this._features.reduce((agg, feature) => {
             agg.push(...feature._internal._getFeaturesWithCode(code));
             return agg;
         }, []);
         this.populateFeatures = (rootFeatureRefs) => {
             this._rootFeatureRefs = rootFeatureRefs;
-            this._features = syncCfgFeatures(rootFeatureRefs, this._features, this.allRawFeatures, this, this.parentProduct, this.rootProduct);
+            this._features = syncCfgFeatures(rootFeatureRefs, this._features, this.allRawFeatures, this, this, this.parentProduct, this.rootProduct);
         };
+        this.setStretchReferenceLength = (measureParamCode, referenceLength, unit, doNotify = true) => __awaiter(this, void 0, void 0, function* () {
+            if (measureParamCode === "") {
+                return false;
+            }
+            if (referenceLength === undefined) {
+                // We assume that referenceLength === undefined shall be ignored.
+                // One can add a measureParam to a Feature in Catalogue Creator
+                // without actually having any numeric values on the Options.
+                // Then this will happen. A previous version of the code assumed
+                // undefined meant reset. However, this does not seem consistent
+                // with CET.
+                return false;
+            }
+            const stretchReferenceLengthsByMeasureParamCode = this.stretchReferenceLengthsByMeasureParamCode;
+            let stretchReferenceLength = stretchReferenceLengthsByMeasureParamCode.get(measureParamCode);
+            const referenceLengthWithUnit = {
+                length: referenceLength,
+                unit,
+            };
+            if (stretchReferenceLength === undefined) {
+                stretchReferenceLengthsByMeasureParamCode.set(measureParamCode, {
+                    def: undefined,
+                    current: referenceLengthWithUnit,
+                });
+            }
+            else {
+                if (stretchReferenceLength.current === referenceLengthWithUnit) {
+                    return false;
+                }
+                stretchReferenceLength.current = referenceLengthWithUnit;
+            }
+            if (doNotify) {
+                yield this._notifyAllOfChange(ProductConfigurationBubbleMode.ToRoot);
+            }
+            return true;
+        });
+        // Useful debug tool:
+        if (false) {
+            const dbgName = `conf${parentProduct.refKey || parentProduct.key}`;
+            window[dbgName] = this;
+            window.conf = this;
+            console.log(`Use "window['${dbgName}']" or window.conf to access conf.`);
+        }
+        /**
+         * Although the measurement-datas are also passed in validate-calls they are only used at
+         * initial product creation. The data is assumed to always be the same for a product, so
+         * after a validate call the product configuration values are what controls how stretched
+         * things are.
+         */
+        const stretchReferenceLengthsByMeasureParamCode = new Map();
+        for (const measurementDefinition of parentProduct.measureDefinitions) {
+            const { measureParamCode, numericValue } = measurementDefinition;
+            if (numericValue === undefined) {
+                continue;
+            }
+            let unit;
+            const rawUnit = numericValue.unit;
+            if (rawUnit === undefined) {
+                unit = parentProduct.unit;
+            }
+            else if (rawUnit === "") {
+                unit = parentProduct.unit;
+                console.warn(`MeasureDefinition unit is empty string for code ${measureParamCode}.`);
+            }
+            else if (isLengthUnit(rawUnit)) {
+                unit = toLengthUnit(rawUnit);
+            }
+            else {
+                console.info(`MeasureDefinition unit is non length: "${rawUnit}" for code ${measureParamCode}. Ignored for stretch.`);
+                continue;
+            }
+            const referenceLength = { length: numericValue.value, unit };
+            stretchReferenceLengthsByMeasureParamCode.set(measureParamCode, {
+                def: referenceLength,
+                current: referenceLength,
+            });
+        }
+        this.stretchReferenceLengthsByMeasureParamCode = stretchReferenceLengthsByMeasureParamCode;
+    }
+    static _makeUninitialized(rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
+    parentProduct, rootProduct) {
+        const configuration = new this(allRawFeatures, parentProduct, rootProduct);
+        configuration.populateFeatures(rootFeatureRefs);
+        return configuration;
     }
     get rootFeatureRefs() {
         return this._rootFeatureRefs;
@@ -127,33 +216,69 @@ export class _CfgProductConfigurationInternal {
         }
     }
 }
-_CfgProductConfigurationInternal._makeUninitialized = (rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
-parentProduct, rootProduct) => {
-    const configuration = new _CfgProductConfigurationInternal(allRawFeatures, parentProduct, rootProduct);
-    configuration.populateFeatures(rootFeatureRefs);
-    return configuration;
-};
 export class CfgProductConfiguration {
-    /// Private constructor and make-method because make new ref requires the constructor to
-    /// take an internal and we don't want those who instantiate CfgProductConfiguration to
-    /// have to be aware of the internal.
+    /**
+     * Private constructor and make-method because make new ref requires the constructor to take an
+     * internal and we don't want those who instantiate CfgProductConfiguration to have to be aware
+     * of the internal.
+     */
     constructor(_internal) {
         this._internal = _internal;
         this.isBackedBySame = (other) => this._internal === other._internal;
         this.structureCompare = (other, strictOrder = true, descriptionMatch = false) => this._internal.structureCompare(other._internal, strictOrder, descriptionMatch);
-        /// This method will try to match the selection from another product configuration
-        /// This method does not propagate its selections.
-        /// This method will cause validation calls.
+        /**
+         * This method will try to match the selection from another product configuration
+         * This method does not propagate its selections.
+         * This method will cause validation calls.
+         */
         this.tryMatchSelection = (other, descriptionMatch = false // Match on case insensitive description, not code
         ) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.tryMatchSelection(other._internal, descriptionMatch, true); });
         this.getApiSelection = () => this._internal.getApiSelection();
-        /// This method does not propagate its selections.
-        /// This method will not cause validation calls. Data is assumed to already be validated.
+        /**
+         * This method does not propagate its selections.
+         * This method will not cause validation calls. Data is assumed to already be validated.
+         */
         this.setApiSelection = (selectedOptions) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(selectedOptions, true); });
+        /**
+         * Set how stretched a certain measure should be measureParamCode is the measure to be
+         * stretched referenceLength is a value relative to the initial length of the measure. If the
+         * stretch drawn up in Model Lab was from the start let's say 2.4 units from start point to end
+         * point a reference value of 4.8 would stretch the start point to end point to double length.
+         * This however does not stop things from extending outside start point to end point. So the
+         * actual perceived length after stretching might have little to do with the referenceLength.
+         * Undefined as referenceLength will clear, that is, make the stretched thing revert to its
+         * default state.
+         */
+        this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => this._internal.setStretchReferenceLength(measureParamCode, referenceLength, unit);
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
         this.stopAllListenForChange = () => this._internal.changeObservable.stopAllListen();
     }
+    /**
+     * This method is semi-async. It will immediately give you a reference to the created
+     * CfgProductConfiguration, but is not properly initialized until the initDone-callback
+     * has been called.
+     */
+    static make(initSuccess, initFail, rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
+    apiSelection, parentProduct, rootProduct) {
+        const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, allRawFeatures, parentProduct, rootProduct);
+        const external = new this(internal);
+        // Note the async-callback at the end of the following line. The call is async.
+        internal
+            .setApiSelection(apiSelection, false)
+            .then(() => initSuccess(external))
+            .catch((e) => initFail(toError(e)));
+        return external;
+    }
+    /**
+     * Makes an object wrapping the passed object. This is not a clone method, it is a method to
+     * make a new outer reference. Like a shallow copy.
+     *
+     * We use this to help frameworks that are built around using equals to detect change.
+     */
+    static _makeNewRefFrom(internal) {
+        return new this(internal);
+    }
     get parentProduct() {
         return CfgProduct._makeNewRefFrom(this._internal.parentProduct);
     }
@@ -163,36 +288,20 @@ export class CfgProductConfiguration {
     get key() {
         return this._internal.key;
     }
-    /// Every (unprocessed) feature which might be used in this product. This is constant for a
-    /// product load. What features are actually used is controlled by rootFeatureRefs
-    /// and what options are selected.
+    /**
+     * Every (unprocessed) feature which might be used in this product. This is constant for a
+     * product load. What features are actually used is controlled by rootFeatureRefs and what
+     * options are selected.
+     */
     get allRawFeatures() {
         return this._internal.allRawFeatures;
     }
-    /// What features are used in the root of this. This can change with new validate calls.
+    /** What features are used in the root of this. This can change with new validate calls. */
     get rootFeatureRefs() {
         return this._internal.rootFeatureRefs;
     }
-    /// The root features at the root of the selection tree.
+    /** The root features at the root of the selection tree. */
     get features() {
         return this._internal.features;
     }
 }
-/// This method is semi-async. It will immediately give you a reference to the created
-/// CfgProductConfiguration, but is not properly initialized until the initDone-callback
-/// has been called.
-CfgProductConfiguration.make = (initSuccess, initFail, rootFeatureRefs, allRawFeatures, // Flat packed. All the features that can appear anyplace in the selection tree.
-apiSelection, parentProduct, rootProduct) => {
-    const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, allRawFeatures, parentProduct, rootProduct);
-    const external = new CfgProductConfiguration(internal);
-    // Note the async-callback at the end of the following line. The call is async.
-    internal
-        .setApiSelection(apiSelection, false)
-        .then(() => initSuccess(external))
-        .catch((e) => initFail(toError(e)));
-    return external;
-};
-/// Makes an object wrapping the passed object. This is not a clone method,
-/// it is a method to make a new outer reference. Like a shallow copy.
-/// We use this to help frameworks that are built around using equals to detect change.
-CfgProductConfiguration._makeNewRefFrom = (internal) => new CfgProductConfiguration(internal);

package/dist/productConfiguration/utilitiesProductConfiguration.d.ts

@@ -4,7 +4,15 @@ import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { CfgFeature } from "./CfgFeature.js";
 import { _CfgOptionInternal } from "./CfgOption.js";
 import { CfgProductConfiguration, _CfgProductConfigurationInternal } from "./CfgProductConfiguration.js";
-export declare function syncCfgFeatures(newFeatureRefs: FeatureRef[], currentFeatures: CfgFeature[], allRawFeatures: Feature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
+/**
+ * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
+ * currentFeatures if they can be found, otherwise makes new.
+ */
+export declare function syncCfgFeatures(newFeatureRefs: FeatureRef[], currentFeatures: CfgFeature[], allRawFeatures: Feature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
 export declare function getMtrlPreview(mtrlApplications: CfgMtrlApplication[] | undefined): string | undefined;
+/**
+ * Recursively find all additional product references given a product configuration.
+ * Only selected options are considered.
+ */
 export declare function collectAdditionalProductRefs(parent: CfgProductConfiguration): AdditionalProductRef[];
 //# sourceMappingURL=utilitiesProductConfiguration.d.ts.map

package/dist/productConfiguration/utilitiesProductConfiguration.js

@@ -2,9 +2,11 @@ import { someMatch } from "@configura/web-utilities";
 import { CfgFeature } from "./CfgFeature.js";
 import { CfgOption } from "./CfgOption.js";
 import { CfgProductConfiguration, } from "./CfgProductConfiguration.js";
-/// Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses
-/// CfgFeatures from currentFeatures if they can be found, otherwise makes new.
-export function syncCfgFeatures(newFeatureRefs, currentFeatures, allRawFeatures, parent, parentProduct, rootProduct) {
+/**
+ * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
+ * currentFeatures if they can be found, otherwise makes new.
+ */
+export function syncCfgFeatures(newFeatureRefs, currentFeatures, allRawFeatures, parent, parentConfiguration, parentProduct, rootProduct) {
     const usedRawFeatures = newFeatureRefs
         .map((r) => r.code)
         .map((c) => {
@@ -17,18 +19,33 @@ export function syncCfgFeatures(newFeatureRefs, currentFeatures, allRawFeatures,
     const hasDuplicateDescription = someMatch(usedRawFeatures, (l, r) => {
         return l.description.toLowerCase() === r.description.toLowerCase();
     });
-    currentFeatures = currentFeatures.slice();
-    return usedRawFeatures.map((f) => {
+    const newFeatures = [];
+    for (const f of usedRawFeatures) {
+        const fCode = f.code;
+        const fDescription = f.description;
+        // It is possible in Cat Creator to add the same Feature twice
+        // to the root of a Product. This fills no apparent purpose,
+        // and in CET the seem to behave as if they were the same.
+        // Removing the duplicates causes sync issues where the server
+        // expects all copies, and hence we short circuit them here
+        // by letting them refer to the same object instead.
+        const twin = newFeatures.find((f) => f.code === fCode);
+        if (twin !== undefined) {
+            newFeatures.push(twin);
+            continue;
+        }
         // Description based code helps when switching between
         // products with similar feature-options tree and trying
         // to retain made selections
-        const key = f.description + (f.description === "" || hasDuplicateDescription ? f.code : "");
-        const i = currentFeatures.findIndex((cfgF) => cfgF.code === f.code && cfgF.key === key);
-        if (i === -1) {
-            return CfgFeature.make(f, allRawFeatures, key, parent, parentProduct, rootProduct);
+        const key = fDescription + (fDescription === "" || hasDuplicateDescription ? fCode : "");
+        const existingFeature = currentFeatures.find((cfgF) => cfgF.code === fCode && cfgF.key === key);
+        if (existingFeature !== undefined) {
+            newFeatures.push(existingFeature);
+            continue;
         }
-        return currentFeatures.splice(i, 1)[0];
-    });
+        newFeatures.push(CfgFeature.make(f, allRawFeatures, key, parent, parentConfiguration, parentProduct, rootProduct));
+    }
+    return newFeatures;
 }
 export function getMtrlPreview(mtrlApplications) {
     if (mtrlApplications === undefined) {
@@ -40,8 +57,10 @@ export function getMtrlPreview(mtrlApplications) {
     }
     return first.previewUrl;
 }
-/// Recursively find all additional product references given a
-/// product configuration. Only selected options are considered.
+/**
+ * Recursively find all additional product references given a product configuration.
+ * Only selected options are considered.
+ */
 export function collectAdditionalProductRefs(parent) {
     function c(parent) {
         const result = [];

package/dist/productLoader.d.ts

@@ -6,7 +6,29 @@ export declare type ProductLoader = {
     getProduct: GetProduct;
     postValidate: PostValidate;
 };
+/**
+ * Wraps a getProduct function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. For this reason we recommend using this with caution.
+ *
+ * In our Example App we use it to cache the internal calls in additional products as in such a
+ * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
+ * four times.
+ */
 export declare function wrapWithGetProductCache(getProduct: GetProduct): GetProduct;
+/**
+ * Wraps a postValidate function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. We recommend you do not use this unless you are really, really sure what you are
+ * doing.
+ *
+ * The SDK uses it for additional products to avoid validating for example the same table legs four
+ * times at the same time. There we make sure the this cache only stays in scope for one user
+ * interaction. No longer than the actions caused by a user clicking an option.
+ */
 export declare function wrapWithPostValidateCache(postValidate: PostValidate): PostValidate;
+/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
 export declare function wrapWithCache(loader: ProductLoader): ProductLoader;
 //# sourceMappingURL=productLoader.d.ts.map

package/dist/productLoader.js

@@ -9,30 +9,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PromiseCache } from "@configura/web-utilities";
 import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js";
-/// Wraps a getProduct function so that it caches for the time it lives.
-/// It has no cache invalidation or timeouts, so whatever ends up in the cache stays
-/// there indefinitely. For this reason we recommend using this with caution.
-/// In our Example App we use it to cache the internal calls in additional products
-/// as in such a product you tend to frequently get calls to same sub-product. Such
-/// as loading the same table leg four times.
+/**
+ * Wraps a getProduct function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. For this reason we recommend using this with caution.
+ *
+ * In our Example App we use it to cache the internal calls in additional products as in such a
+ * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
+ * four times.
+ */
 export function wrapWithGetProductCache(getProduct) {
     const cache = new PromiseCache();
     return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params, params.partNumber), () => getProduct(params)); });
 }
-/// Wraps a postValidate function so that it caches for the time it lives.
-/// It has no cache invalidation or timeouts, so whatever ends up in the cache stays
-/// there indefinitely. We recommend you do not use this unless you are really, really
-/// sure what you are doing.
-/// We use it in additional products to avoid validating for example the same table legs four
-/// times at the same time. There we make sure the this cache only stays in scope for one
-/// user interaction. No longer than the actions caused by a user clicking an option.
+/**
+ * Wraps a postValidate function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. We recommend you do not use this unless you are really, really sure what you are
+ * doing.
+ *
+ * The SDK uses it for additional products to avoid validating for example the same table legs four
+ * times at the same time. There we make sure the this cache only stays in scope for one user
+ * interaction. No longer than the actions caused by a user clicking an option.
+ */
 export function wrapWithPostValidateCache(postValidate) {
     const cache = new PromiseCache();
     return (params, body) => __awaiter(this, void 0, void 0, function* () {
         return cache.get(`${makeProductKey(params, params.partNumber)}-${makeSelOptionsKey(body.selOptions)}`, () => postValidate(params, body));
     });
 }
-// Does both wrapWithGetProductCache and wrapWithPostValidateCache
+/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
 export function wrapWithCache(loader) {
     return {
         getProduct: wrapWithGetProductCache(loader.getProduct.bind(loader)),

package/dist/tests/testData/dummyProductForTest.js

@@ -10,6 +10,7 @@ export const getDummyCfgProduct = () => CfgProduct.make({
     getProduct: () => Promise.resolve({
         features: [],
         uuid: "uuid",
+        unit: "m",
         rootFeatureRefs: [],
         productData: {
             sku: "sku",