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

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -1,346 +1,355 @@
-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 { compareArrays, count, isEqualLength, isLengthUnit, Observable, toError, toLengthUnit, } from "@configura/web-utilities";
-import { CfgProduct } from "../CfgProduct.js";
-import { convertDtoFeatureConfsToSelOptions } from "../utilitiesConfiguration.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.
- */
-export class _CfgProductConfigurationInternal {
-    constructor(rawFeatures, parentProduct, rootProduct, _initialRootFeatureRefs) {
-        this.parentProduct = parentProduct;
-        this.rootProduct = rootProduct;
-        this._initialRootFeatureRefs = _initialRootFeatureRefs;
-        this.key = "~";
-        this._rootFeatureRefs = [];
-        this.accumulatedRawFeatures = []; // Flat packed. May be extended in validate calls.
-        this._features = [];
-        this.changeObservable = new Observable();
-        this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
-            if (bubbleMode === ProductConfigurationBubbleMode.Stop) {
-                return;
-            }
-            const freshRef = CfgProductConfiguration._makeNewRefFrom(this);
-            const parent = this.parentProduct;
-            this.changeObservable.notifyAll({
-                freshRef,
-                committed,
-            });
-            if (parent === undefined) {
-                return;
-            }
-            yield parent._configurationHasChanged(freshRef, bubbleMode === ProductConfigurationBubbleMode.OneLevel
-                ? ProductConfigurationBubbleMode.Stop
-                : bubbleMode, committed);
-        });
-        /** Called by child to tell its parent that it has changed. */
-        this._childHasChanged = (freshRef, bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
-            const features = this._features;
-            const i = features.findIndex((a) => a.isBackedBySame(freshRef));
-            if (i === -1) {
-                throw Error("Child feature not found");
-            }
-            features[i] = freshRef;
-            yield this._notifyAllOfChange(bubbleMode, committed);
-        });
-        this.getDtoConf = (includeExtendedData) => this._features.map((f) => f._internal.getDtoConf(includeExtendedData));
-        this.getApiSelection = () => convertDtoFeatureConfsToSelOptions(this.getDtoConf(false), true);
-        this.getApiConstrained = () => this._features.map((f) => {
-            const next = {};
-            f._internal.addForApiConstrained(next);
-            return {
-                code: "!~!",
-                feature: "",
-                next,
-            };
-        });
-        /**
-         * 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 method will not cause validation calls. Data is assumed to already be validated.
-         */
-        this.setApiSelection = (selectedOptions, constrOptions, bubbleToRoot) => __awaiter(this, void 0, void 0, function* () {
-            const featuresLength = this._features.length;
-            const selectedOptionsLength = selectedOptions.length;
-            if (featuresLength !== selectedOptionsLength) {
-                throw new Error(`Wrong selection count. Features on this configuration: ${featuresLength}. Passed feature count: ${selectedOptionsLength}.`);
-            }
-            if (constrOptions && featuresLength !== constrOptions.length) {
-                throw new Error(`Wrong constraint feature count. Features on this configuration: ${featuresLength}. Passed constraint feature count: ${constrOptions.length}.`);
-            }
-            const change = (yield Promise.all(this._features.map((f, i) => {
-                var _a;
-                return f._internal.setApiSelection(selectedOptions[i].next, (_a = (constrOptions !== null && constrOptions !== void 0 ? constrOptions : [])[i]) === null || _a === void 0 ? void 0 : _a.next);
-            }))).some((b) => b);
-            if (change) {
-                yield this._notifyAllOfChange(bubbleToRoot
-                    ? ProductConfigurationBubbleMode.ToRoot
-                    : ProductConfigurationBubbleMode.OneLevel, true);
-            }
-            return change;
-        });
-        this.structureCompare = (other, strictOrder, descriptionMatch) => 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.
-         */
-        this.tryMatchSelection = (other, descriptionMatch = false, // Match on case insensitive description, not code
-        validate) => __awaiter(this, void 0, void 0, function* () {
-            const thisFeatures = this.features;
-            const otherFeatures = other.features;
-            const change = (yield Promise.all(otherFeatures.map((otherF) => (() => __awaiter(this, void 0, void 0, function* () {
-                if (1 <
-                    count(otherFeatures, (item) => item._internal.keyMatch(otherF._internal, descriptionMatch))) {
-                    console.warn("tryMatchSelection will ignore items with same key");
-                    return false;
-                }
-                const toSetFeatures = thisFeatures.filter((f) => f._internal.keyMatch(otherF._internal, descriptionMatch));
-                if (1 < toSetFeatures.length) {
-                    console.warn("tryMatchSelection will ignore items with same key");
-                    return false;
-                }
-                if (toSetFeatures.length === 0) {
-                    return false;
-                }
-                return yield toSetFeatures[0]._internal.tryMatchSelection(otherF._internal, descriptionMatch);
-            }))()))).some((b) => b);
-            if (change) {
-                yield this._notifyAllOfChange(validate
-                    ? ProductConfigurationBubbleMode.Validate
-                    : ProductConfigurationBubbleMode.OneLevel, true);
-            }
-            return change;
-        });
-        /** Only selected features. */
-        this._getFeaturesWithCode = (code) => this._features.reduce((agg, feature) => {
-            agg.push(...feature._internal._getFeaturesWithCode(code));
-            return agg;
-        }, []);
-        /**
-         * Extends the list of loaded potentially used features. Will warn for but ignore duplicates.
-         * Returns true if a change happened.
-         */
-        this.addRawFeatures = (rawFeatures, warnForDuplicates) => {
-            let change = false;
-            const accumulatedRawFeatures = this.accumulatedRawFeatures;
-            for (const rawFeature of rawFeatures) {
-                const code = rawFeature.code;
-                if (accumulatedRawFeatures.find((f) => code === f.code)) {
-                    if (warnForDuplicates) {
-                        console.warn(`Feature ${code} was already loaded. Will ignore it.`);
-                    }
-                    continue;
-                }
-                accumulatedRawFeatures.push(rawFeature);
-                change = true;
-            }
-            return change;
-        };
-        this._hasRootFeaturesChanged = false;
-        /**
-         * Populates _features based on the passed @param rootFeatureRefs .
-         * @return true if a change happened.
-         */
-        this.populateFeatures = (rootFeatureRefs) => {
-            if (compareArrays(this._rootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code, true)) {
-                return false;
-            }
-            this._rootFeatureRefs = rootFeatureRefs;
-            this._hasRootFeaturesChanged = !compareArrays(this._initialRootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code);
-            this._features = syncCfgFeatures(rootFeatureRefs, this._features, this.accumulatedRawFeatures, this, this, this.parentProduct, this.rootProduct);
-            return true;
-        };
-        this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => __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;
-            const stretchReferenceLength = stretchReferenceLengthsByMeasureParamCode.get(measureParamCode);
-            const referenceLengthWithUnit = {
-                length: referenceLength,
-                unit,
-            };
-            if (stretchReferenceLength === undefined) {
-                stretchReferenceLengthsByMeasureParamCode.set(measureParamCode, {
-                    def: undefined,
-                    current: referenceLengthWithUnit,
-                });
-            }
-            else {
-                if (isEqualLength(stretchReferenceLength.current, referenceLengthWithUnit)) {
-                    return false;
-                }
-                stretchReferenceLength.current = referenceLengthWithUnit;
-            }
-            yield this._notifyAllOfChange(ProductConfigurationBubbleMode.ToRoot, false);
-            return true;
-        });
-        /* eslint-disable */
-        // 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.`);
-        }
-        /* eslint-enable */
-        this.addRawFeatures(rawFeatures, true);
-        this.populateFeatures(_initialRootFeatureRefs);
-        /**
-         * 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, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
-    parentProduct, rootProduct) {
-        return new this(rawFeatures, parentProduct, rootProduct, rootFeatureRefs);
-    }
-    get rootFeatureRefs() {
-        return this._rootFeatureRefs;
-    }
-    // The root features at the root of the selection tree.
-    get features() {
-        return this._features;
-    }
-    /**
-     * True if what root Features are used is not the same as at initial load.
-     * This means that functional selection has happened.
-     */
-    get hasRootFeaturesChanged() {
-        return this._hasRootFeaturesChanged;
-    }
-}
-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.
-     */
-    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.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); });
-        /**
-         * 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, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
-    apiSelection, apiConstraints, parentProduct, rootProduct) {
-        const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, rawFeatures, 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, apiConstraints, 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);
-    }
-    get rootProduct() {
-        return CfgProduct._makeNewRefFrom(this._internal.rootProduct);
-    }
-    get key() {
-        return this._internal.key;
-    }
-    /**
-     * Every (unprocessed) feature that is currently loaded for this product. This can be extended
-     * by validation calls. What features are actually used is controlled by rootFeatureRefs and what
-     * options are selected.
-     */
-    get rawFeatures() {
-        return this._internal.accumulatedRawFeatures;
-    }
-    /** 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. */
-    get features() {
-        return this._internal.features;
-    }
-}
+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 { compareArrays, count, isEqualLength, isLengthUnit, Observable, toError, toLengthUnit, } from "@configura/web-utilities";
+import { CfgProduct } from "../CfgProduct.js";
+import { convertDtoFeatureConfsToSelOptions } from "../utilitiesConfiguration.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.
+ */
+export class _CfgProductConfigurationInternal {
+    constructor(rawFeatures, parentProduct, rootProduct, _initialRootFeatureRefs) {
+        this.parentProduct = parentProduct;
+        this.rootProduct = rootProduct;
+        this._initialRootFeatureRefs = _initialRootFeatureRefs;
+        this.key = "~";
+        this._rootFeatureRefs = [];
+        this.accumulatedRawFeatures = []; // Flat packed. May be extended in validate calls.
+        this._features = [];
+        this.changeObservable = new Observable();
+        this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
+            if (bubbleMode === ProductConfigurationBubbleMode.Stop) {
+                return;
+            }
+            const freshRef = CfgProductConfiguration._makeNewRefFrom(this);
+            const parent = this.parentProduct;
+            this.changeObservable.notifyAll({
+                freshRef,
+                committed,
+            });
+            if (parent === undefined) {
+                return;
+            }
+            yield parent._configurationHasChanged(freshRef, bubbleMode === ProductConfigurationBubbleMode.OneLevel
+                ? ProductConfigurationBubbleMode.Stop
+                : bubbleMode, committed);
+        });
+        /** Called by child to tell its parent that it has changed. */
+        this._childHasChanged = (freshRef, bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
+            const features = this._features;
+            const i = features.findIndex((a) => a.isBackedBySame(freshRef));
+            if (i === -1) {
+                throw Error("Child feature not found");
+            }
+            features[i] = freshRef;
+            yield this._notifyAllOfChange(bubbleMode, committed);
+        });
+        this.getDtoConf = (includeExtendedData) => this._features.map((f) => f._internal.getDtoConf(includeExtendedData));
+        this.getApiSelection = () => convertDtoFeatureConfsToSelOptions(this.getDtoConf(false), true);
+        this.getApiConstrained = () => this._features.map((f) => {
+            const next = {};
+            f._internal.addForApiConstrained(next);
+            return {
+                code: "!~!",
+                feature: "",
+                next,
+            };
+        });
+        /**
+         * 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 method will not cause validation calls. Data is assumed to already be validated.
+         */
+        this.setApiSelection = (selectedOptions, constrOptions, bubbleToRoot) => __awaiter(this, void 0, void 0, function* () {
+            const featuresLength = this._features.length;
+            const selectedOptionsLength = selectedOptions.length;
+            if (featuresLength !== selectedOptionsLength) {
+                throw new Error(`Wrong selection count. Features on this configuration: ${featuresLength}. Passed feature count: ${selectedOptionsLength}.`);
+            }
+            if (constrOptions && featuresLength !== constrOptions.length) {
+                throw new Error(`Wrong constraint feature count. Features on this configuration: ${featuresLength}. Passed constraint feature count: ${constrOptions.length}.`);
+            }
+            const change = (yield Promise.all(this._features.map((f, i) => {
+                var _a;
+                return f._internal.setApiSelection(selectedOptions[i].next, (_a = (constrOptions !== null && constrOptions !== void 0 ? constrOptions : [])[i]) === null || _a === void 0 ? void 0 : _a.next);
+            }))).some((b) => b);
+            if (change) {
+                yield this._notifyAllOfChange(bubbleToRoot
+                    ? ProductConfigurationBubbleMode.ToRoot
+                    : ProductConfigurationBubbleMode.OneLevel, true);
+            }
+            return change;
+        });
+        this.structureCompare = (other, strictOrder, descriptionMatch) => 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.
+         */
+        this.tryMatchSelection = (other, descriptionMatch = false, // Match on case insensitive description, not code
+        validate) => __awaiter(this, void 0, void 0, function* () {
+            const thisFeatures = this.features;
+            const otherFeatures = other.features;
+            const change = (yield Promise.all(otherFeatures.map((otherF) => (() => __awaiter(this, void 0, void 0, function* () {
+                if (1 <
+                    count(otherFeatures, (item) => item._internal.keyMatch(otherF._internal, descriptionMatch))) {
+                    console.warn("tryMatchSelection will ignore items with same key");
+                    return false;
+                }
+                const toSetFeatures = thisFeatures.filter((f) => f._internal.keyMatch(otherF._internal, descriptionMatch));
+                if (1 < toSetFeatures.length) {
+                    console.warn("tryMatchSelection will ignore items with same key");
+                    return false;
+                }
+                if (toSetFeatures.length === 0) {
+                    return false;
+                }
+                return yield toSetFeatures[0]._internal.tryMatchSelection(otherF._internal, descriptionMatch);
+            }))()))).some((b) => b);
+            if (change) {
+                yield this._notifyAllOfChange(validate
+                    ? ProductConfigurationBubbleMode.Validate
+                    : ProductConfigurationBubbleMode.OneLevel, true);
+            }
+            return change;
+        });
+        /** Only selected features. */
+        this._getFeaturesWithCode = (code) => this._features.reduce((agg, feature) => {
+            agg.push(...feature._internal._getFeaturesWithCode(code));
+            return agg;
+        }, []);
+        /**
+         * Extends the list of loaded potentially used features. Will warn for but ignore duplicates.
+         * Returns true if a change happened.
+         */
+        this.addRawFeatures = (rawFeatures, warnForDuplicates) => {
+            let change = false;
+            const accumulatedRawFeatures = this.accumulatedRawFeatures;
+            for (const rawFeature of rawFeatures) {
+                const code = rawFeature.code;
+                if (accumulatedRawFeatures.find((f) => code === f.code)) {
+                    if (warnForDuplicates) {
+                        console.warn(`Feature ${code} was already loaded. Will ignore it.`);
+                    }
+                    continue;
+                }
+                accumulatedRawFeatures.push(rawFeature);
+                change = true;
+            }
+            return change;
+        };
+        this._hasRootFeaturesChanged = false;
+        /**
+         * Populates _features based on the passed @param rootFeatureRefs .
+         * @return true if a change happened.
+         */
+        this.populateFeatures = (rootFeatureRefs) => {
+            if (compareArrays(this._rootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code, true)) {
+                return false;
+            }
+            this._rootFeatureRefs = rootFeatureRefs;
+            this._hasRootFeaturesChanged = !compareArrays(this._initialRootFeatureRefs, rootFeatureRefs, (l, r) => l.code === r.code);
+            this._features = syncCfgFeatures(rootFeatureRefs, this._features, this.accumulatedRawFeatures, this, this, this.parentProduct, this.rootProduct);
+            return true;
+        };
+        this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => __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;
+            const stretchReferenceLength = stretchReferenceLengthsByMeasureParamCode.get(measureParamCode);
+            const referenceLengthWithUnit = {
+                length: referenceLength,
+                unit,
+            };
+            if (stretchReferenceLength === undefined) {
+                stretchReferenceLengthsByMeasureParamCode.set(measureParamCode, {
+                    def: undefined,
+                    current: referenceLengthWithUnit,
+                });
+            }
+            else {
+                if (isEqualLength(stretchReferenceLength.current, referenceLengthWithUnit)) {
+                    return false;
+                }
+                stretchReferenceLength.current = referenceLengthWithUnit;
+            }
+            yield this._notifyAllOfChange(ProductConfigurationBubbleMode.ToRoot, false);
+            return true;
+        });
+        /* eslint-disable */
+        // 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.`);
+        }
+        /* eslint-enable */
+        this.addRawFeatures(rawFeatures, true);
+        this.populateFeatures(_initialRootFeatureRefs);
+    }
+    static _makeUninitialized(rootFeatureRefs, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
+    parentProduct, rootProduct) {
+        return new this(rawFeatures, parentProduct, rootProduct, rootFeatureRefs);
+    }
+    get stretchReferenceLengthsByMeasureParamCode() {
+        if (this._stretchReferenceLengthsByMeasureParamCode === undefined) {
+            const stretchMap = new Map();
+            for (const measurementDefinition of this.parentProduct.measureDefinitions) {
+                const { measureParamCode, numericValue } = measurementDefinition;
+                if (numericValue === undefined) {
+                    continue;
+                }
+                let unit;
+                const rawUnit = numericValue.unit;
+                if (rawUnit === undefined) {
+                    unit = this.parentProduct.unit;
+                }
+                else if (rawUnit === "") {
+                    unit = this.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 };
+                stretchMap.set(measureParamCode, {
+                    def: referenceLength,
+                    current: referenceLength,
+                });
+            }
+            this._stretchReferenceLengthsByMeasureParamCode = stretchMap;
+        }
+        return this._stretchReferenceLengthsByMeasureParamCode;
+    }
+    clearStretchMeasurements() {
+        this._stretchReferenceLengthsByMeasureParamCode = undefined;
+    }
+    get rootFeatureRefs() {
+        return this._rootFeatureRefs;
+    }
+    // The root features at the root of the selection tree.
+    get features() {
+        return this._features;
+    }
+    /**
+     * True if what root Features are used is not the same as at initial load.
+     * This means that functional selection has happened.
+     */
+    get hasRootFeaturesChanged() {
+        return this._hasRootFeaturesChanged;
+    }
+}
+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.
+     */
+    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.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); });
+        /**
+         * 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, rawFeatures, // Flat packed. All the features that can currently appear anyplace in the selection tree.
+    apiSelection, apiConstraints, parentProduct, rootProduct) {
+        const internal = _CfgProductConfigurationInternal._makeUninitialized(rootFeatureRefs, rawFeatures, 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, apiConstraints, 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);
+    }
+    get rootProduct() {
+        return CfgProduct._makeNewRefFrom(this._internal.rootProduct);
+    }
+    get key() {
+        return this._internal.key;
+    }
+    /**
+     * Every (unprocessed) feature that is currently loaded for this product. This can be extended
+     * by validation calls. What features are actually used is controlled by rootFeatureRefs and what
+     * options are selected.
+     */
+    get rawFeatures() {
+        return this._internal.accumulatedRawFeatures;
+    }
+    /** 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. */
+    get features() {
+        return this._internal.features;
+    }
+    /**
+     * Clears cached stretch measurement map. Called by the parent product when the
+     * rawProductData has changed, which may potentially change the measurements.
+     */
+    clearStretchMeasurements() {
+        this._internal.clearStretchMeasurements();
+    }
+}