@configura/web-api 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/CfgProduct.js

@@ -9,13 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { AggregatedLoadingObservable, assert, assertDefined, augmentErrorMessage, compareArrays, count, Observable, toLengthUnit, } from "@configura/web-utilities";
 import { CfgMeasureDefinition } from "./CfgMeasure.js";
-import { convertDtoConfProdToV1 } from "./ConfigurationConverter.js";
+import { convertDtoProductConfToV1 } from "./ConfigurationConverter.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
 import { CfgProductConfiguration } from "./productConfiguration/CfgProductConfiguration.js";
 import { collectAdditionalProductRefs } from "./productConfiguration/utilitiesProductConfiguration.js";
 import { wrapWithCache } from "./productLoader.js";
 import { SyncGroupsHandler } from "./syncGroups/SyncGroupsHandler.js";
-import { comparePricesObjects, correctDefaultsOnCatalogueParams, isSameCatalogueParams, isSameProductRef, makeProductKey, } from "./utilitiesCatalogueData.js";
+import { compareCfgProductData, comparePricesObjects, correctDefaultsOnCatalogueParams, isSameCatalogueParams, isSameProductRef, makeProductKey, } from "./utilitiesCatalogueData.js";
 function completeSettings(incompleteSettings) {
     var _a;
     return {
@@ -52,7 +52,7 @@ function isDescriptionMatch(l, r) {
  * the class that should be used and interacted with.
  */
 export class _CfgProductInternal {
-    constructor(initSuccess, initFail, _productLoaderRaw, prodParams, settings, optional, selected, rootFeatureRefs, allRawFeatures, uuid, _rawUnit, _rawProductData, apiSelection, loadingObservable, parent, root, _additionalProductRef, _syncGroupHandler) {
+    constructor(initSuccess, initFail, _productLoaderRaw, prodParams, settings, optional, selected, rootFeatureRefs, rawFeatures, uuid, _rawUnit, _rawProductData, apiSelection, loadingObservable, parent, root, _additionalProductRef, _syncGroupHandler) {
         var _a;
         this._productLoaderRaw = _productLoaderRaw;
         this.prodParams = prodParams;
@@ -67,14 +67,24 @@ export class _CfgProductInternal {
         this._destroyed = false;
         this.additionalProducts = [];
         this.changeObservable = new Observable();
+        /** Mark this and its descendants as destroyed and remove all listeners */
         this.destroy = () => {
+            var _a;
             this._destroyed = true;
             this.changeObservable.stopAllListen();
             this.configuration.stopAllListenForChange();
-            for (const additionalProduct of this.additionalProducts || []) {
+            for (const additionalProduct of (_a = this.additionalProducts) !== null && _a !== void 0 ? _a : []) {
                 additionalProduct.destroy();
             }
         };
+        /**
+         * Reset will reset the product to its initial state
+         */
+        this.reset = () => __awaiter(this, void 0, void 0, function* () {
+            if (this._initialClone !== undefined) {
+                yield this.copyFrom(this._initialClone, true);
+            }
+        });
         this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             if (bubbleMode === CfgProductBubbleMode.Stop) {
                 return;
@@ -164,12 +174,14 @@ export class _CfgProductInternal {
             }
             return conf;
         };
-        this.setDtoConf = (s, doValidate, productLoaderForGroupedLoad) => this.setApiSelection(convertDtoConfProdToV1(s), doValidate, productLoaderForGroupedLoad);
+        this.setDtoConf = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.setApiSelection(convertDtoProductConfToV1(s), doValidate, productLoaderForGroupedLoad);
+        });
         this.setApiSelection = (s, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return this._setApiSelectionWithOtherProduct(s, doValidate, productLoaderForGroupedLoad, undefined);
+            return yield this._setApiSelectionWithOtherProduct(s, doValidate, productLoaderForGroupedLoad, undefined);
         });
         this.copyFrom = (source, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
-            return yield this._setApiSelectionWithOtherProduct(convertDtoConfProdToV1(source.getDtoConf(false, false)), doValidate, productLoaderForGroupedLoad, source);
+            return yield this._setApiSelectionWithOtherProduct(convertDtoProductConfToV1(source.getDtoConf(false, false)), doValidate, productLoaderForGroupedLoad, source);
         });
         this._setApiSelectionWithOtherProduct = (s, doValidate, productLoaderForGroupedLoad, sourceProduct) => __awaiter(this, void 0, void 0, function* () {
             // Wrap with cache will make getProduct for this function call use the same server call
@@ -179,9 +191,16 @@ export class _CfgProductInternal {
                 productLoaderForGroupedLoad || wrapWithCache(this._productLoaderRaw);
             let change = false;
             if (sourceProduct !== undefined) {
-                this._rawProductData = sourceProduct.rawProductData;
-                this.configuration._internal.populateFeatures(sourceProduct.configuration.rootFeatureRefs);
-                change = true; // We can not know if this is an actual change, so we assume it is
+                if (!compareCfgProductData(this._rawProductData, sourceProduct.rawProductData)) {
+                    this._rawProductData = sourceProduct.rawProductData;
+                    change = true;
+                }
+                if (this.configuration._internal.addRawFeatures(sourceProduct.configuration.rawFeatures, false)) {
+                    change = true;
+                }
+                if (this.configuration._internal.populateFeatures(sourceProduct.configuration.rootFeatureRefs)) {
+                    change = true;
+                }
             }
             const configurationChange = yield this.configuration._internal.setApiSelection(s.selOptions, false);
             if (configurationChange) {
@@ -203,8 +222,8 @@ export class _CfgProductInternal {
             const sourceProductAdditionalProducts = sourceProduct === null || sourceProduct === void 0 ? void 0 : sourceProduct.additionalProducts;
             assert(!sourceProductAdditionalProducts ||
                 additionalProductsCount === sourceProductAdditionalProducts.length, `Passed sourceProduct does not have the same number of additional products as this.`);
-            if ((yield Promise.all(apiSelectionAdditionalProducts.map((apiSelectionAdditionalProduct, index) => {
-                var _a;
+            if ((yield Promise.all(apiSelectionAdditionalProducts.map((apiSelectionAdditionalProduct) => __awaiter(this, void 0, void 0, function* () {
+                var _b;
                 const refKey = apiSelectionAdditionalProduct.refKey;
                 assertDefined(refKey, "Additional product api configurations must have refKey.");
                 const i = additionalProducts.findIndex((a) => refKey === a.refKey);
@@ -212,12 +231,12 @@ export class _CfgProductInternal {
                 let sourceProductAdditionalProduct = undefined;
                 if (sourceProductAdditionalProducts !== undefined) {
                     sourceProductAdditionalProduct =
-                        (_a = sourceProductAdditionalProducts.find((a) => refKey === a.refKey)) === null || _a === void 0 ? void 0 : _a._internal;
+                        (_b = sourceProductAdditionalProducts.find((a) => refKey === a.refKey)) === null || _b === void 0 ? void 0 : _b._internal;
                     assertDefined(sourceProductAdditionalProduct, "Additional product not found in sourceProduct");
                 }
                 const additionalProduct = additionalProducts.splice(i, 1)[0]; // Splicing like this is okay because this is done synchronous. The setCon. is what is async.
-                return additionalProduct._internal._setApiSelectionWithOtherProduct(apiSelectionAdditionalProduct, doValidate, productLoaderForGroupedLoad, sourceProductAdditionalProduct);
-            }))).some((b) => b)) {
+                return yield additionalProduct._internal._setApiSelectionWithOtherProduct(apiSelectionAdditionalProduct, doValidate, productLoaderForGroupedLoad, sourceProductAdditionalProduct);
+            })))).some((b) => b)) {
                 change = true;
             }
             if (doValidate && configurationChange) {
@@ -310,7 +329,10 @@ export class _CfgProductInternal {
             const token = this.loadingObservable.startChildLoading();
             this._revalidateInProgressToken = token;
             try {
-                const response = yield productLoader.postValidate(correctDefaultsOnCatalogueParams(this.prodParams), { selOptions: configuration.getApiSelection() });
+                const response = yield productLoader.postValidate(correctDefaultsOnCatalogueParams(this.prodParams), {
+                    selOptions: configuration._internal.getApiSelection(),
+                    knownFeatureCodes: configuration.rawFeatures.map((f) => f.code),
+                });
                 // The revalidateInProgressToken is used to know if some other revalidate
                 // call has happened after this call, thereby making this call obsolete.
                 // This is a bit crude in that it does not actually cancel previous validate
@@ -329,9 +351,10 @@ export class _CfgProductInternal {
                 if (this._destroyed) {
                     return false;
                 }
-                const { productData, rootFeatureRefs } = response;
+                const { productData, rootFeatureRefs, features } = response;
                 const pricesUpdated = !comparePricesObjects(this.prices, productData.partsData.prices);
                 this._rawProductData = productData;
+                configuration._internal.addRawFeatures(features, true);
                 if (rootFeatureRefs !== undefined) {
                     configuration._internal.populateFeatures(rootFeatureRefs);
                 }
@@ -348,7 +371,7 @@ export class _CfgProductInternal {
                 return true;
             }
             catch (e) {
-                throw augmentErrorMessage(e, "Validate product configuration request failure");
+                throw augmentErrorMessage(e, `Validate product configuration request (${this.prodParams.partNumber}) failure`);
             }
             finally {
                 this.loadingObservable.stopChildLoading(token);
@@ -421,19 +444,25 @@ export class _CfgProductInternal {
         this.root = root !== null && root !== void 0 ? root : this;
         this.key = makeProductKey(Object.assign(Object.assign({}, prodParams), { partNumber: (_a = _additionalProductRef === null || _additionalProductRef === void 0 ? void 0 : _additionalProductRef.refKey) !== null && _a !== void 0 ? _a : prodParams.partNumber }));
         this._selected = optional ? selected : undefined;
-        this.isAdditionalProduct = parent !== undefined;
-        this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, allRawFeatures, apiSelection, this, this.root);
+        this.isAdditionalProduct = _additionalProductRef !== undefined;
+        this._configuration = CfgProductConfiguration.make(initSuccess, initFail, rootFeatureRefs, rawFeatures, apiSelection, this, this.root);
     }
     get selected() {
         return this._selected !== false;
     }
+    /**
+     * Please note that cloning an additional product will make the clone believe is is
+     * an additional product, even if it has no parent and root.
+     * Providing the parent and root of what you clone as arguments is unwise as it will
+     * make changes you do on the clone be propagated up to the original non-clone root product.
+     */
     clone(parent, root) {
         return __awaiter(this, void 0, void 0, function* () {
             const product = yield new Promise((initSuccess, initFail) => {
                 var _a;
                 const p = new _CfgProductInternal(() => {
                     initSuccess(p);
-                }, initFail, this._productLoaderRaw, this.prodParams, this.settings, this.optional, this.selected, this._configuration.rootFeatureRefs, this._configuration.allRawFeatures, this.uuid, this._rawUnit, this._rawProductData, this.configuration.getApiSelection(), new AggregatedLoadingObservable(), parent, root, this._additionalProductRef, (_a = this._syncGroupHandler) === null || _a === void 0 ? void 0 : _a.clone());
+                }, initFail, this._productLoaderRaw, this.prodParams, this.settings, this.optional, this.selected, this._configuration.rootFeatureRefs, this._configuration.rawFeatures, this.uuid, this._rawUnit, this._rawProductData, this.configuration._internal.getApiSelection(), new AggregatedLoadingObservable(), parent, root, this._additionalProductRef, (_a = this._syncGroupHandler) === null || _a === void 0 ? void 0 : _a.clone());
             });
             for (const additionalProduct of this.additionalProducts) {
                 product.additionalProducts.push(CfgProduct._makeNewRefFrom(yield additionalProduct._internal.clone(product, root || product)));
@@ -441,12 +470,21 @@ export class _CfgProductInternal {
             return product;
         });
     }
+    /**
+     * Internal use. Used when this product is an additional product, and
+     * changing a parent product has made the settings for this product
+     * change.
+     */
     _updateAdditionalProdRef(p) {
         this._additionalProductRef = p;
         if (p.optional !== this.optional) {
             this._selected = p.optional ? false : undefined;
         }
     }
+    get hasRootFeaturesChanged() {
+        return (this._configuration._internal.hasRootFeaturesChanged ||
+            this.additionalProducts.some((p) => p._internal.hasRootFeaturesChanged));
+    }
     get description() {
         var _a, _b;
         return (_b = (_a = this._additionalProductRef) === null || _a === void 0 ? void 0 : _a.refDescription) !== null && _b !== void 0 ? _b : this._rawProductData.description;
@@ -530,7 +568,19 @@ export class _CfgProductInternal {
             if (this._selected === v) {
                 return false;
             }
+            // Vitally important that this happens before the call to reset. An optional
+            // additional product is always deselected at start, so this way the reset won't cause
+            // infinite loops
             this._selected = v;
+            if (!v) {
+                yield this.reset();
+            }
+            if (v) {
+                const syncGroupHandler = this.syncGroupHandler;
+                if (syncGroupHandler !== undefined) {
+                    yield syncGroupHandler.init(this.root, wrapWithCache(this._productLoaderRaw));
+                }
+            }
             yield this._notifyAllOfChange(bubbleMode, true);
             return true;
         });
@@ -594,22 +644,26 @@ prodParams, settings, optional, loadingObservable, parent, root, additionalProdu
         : undefined;
     try {
         const productResponse = yield productLoaderForGroupedLoad.getProduct(correctDefaultsOnCatalogueParams(prodParams));
-        const { productData, rootFeatureRefs, features: allRawFeatures, uuid, unit, } = productResponse;
+        const { productData, rootFeatureRefs, features: rawFeatures, uuid, unit, } = productResponse;
         const product = yield new Promise((initSuccess, initFail) => {
+            var _a;
             const p = new _CfgProductInternal(() => {
                 // We absolutely do not want anyone to assign to this._configuration. So we want that field private.
                 // But we can not set the api selection synchronously. And the product configuration needs "this". So we use this callback.
                 // Feel free to find a nicer more readable solution :)
                 initSuccess(p);
-            }, initFail, productLoaderRaw, prodParams, settings, optional, !optional, rootFeatureRefs, allRawFeatures, uuid, unit, productData, productData.partsData.selOptions || [], loadingObservable, parent, root, additionalProductRef, syncGroupHandler);
+            }, initFail, productLoaderRaw, prodParams, settings, optional, !optional, rootFeatureRefs, rawFeatures, uuid, unit, productData, (_a = productData.partsData.selOptions) !== null && _a !== void 0 ? _a : [], loadingObservable, parent, root, additionalProductRef, syncGroupHandler);
         });
         yield product._syncAndLoadAdditionalProducts(productLoaderForGroupedLoad);
-        // Product is guaranteed to be root
-        yield (syncGroupHandler === null || syncGroupHandler === void 0 ? void 0 : syncGroupHandler.init(product, productLoaderForGroupedLoad));
+        product._initialClone = yield product.clone();
+        if (syncGroupHandler !== undefined) {
+            // As syncGroupHandler is only set for root product we know that we will init with root
+            yield syncGroupHandler.init(product, productLoaderForGroupedLoad);
+        }
         return product;
     }
     catch (e) {
-        throw augmentErrorMessage(e, "Load product request failure");
+        throw augmentErrorMessage(e, `Load product request (${prodParams.partNumber}) failure`);
     }
 });
 export class CfgProduct {
@@ -648,11 +702,43 @@ export class CfgProduct {
          * Gets what selections has been made on the product, recursively including product
          * configuration, optional products and additional products. Used when a full view of all
          * selections on a product is needed, such as when doing Render or Export.
+         * @deprecated getDtoConf provides a newer format.
+         * @see getDtoConf
+         */
+        this.getApiSelection = () => convertDtoProductConfToV1(this._internal.getDtoConf(false, false), true);
+        /**
+         * Applies the configuration (selections) in the passed object onto the product recursively
+         * including product configuration, optional products and additional products.
+         * @param doValidate Makes a server side validation call. These are necessary to ensure that
+         *                   the right models are loaded.
+         * @deprecated setDtoConf uses a newer format.
+         */
+        this.setApiSelection = (configuration, doValidate = true) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(configuration, doValidate); });
+        /**
+         * A newer alternative version of getApiSelection. This returns the configuration (selections)
+         * on the product, recursively including product configuration, optional products and additional
+         * products.
+         * This version has the following advantages over getApiSelection:
+         * - The format is clearer, designed to be readable
+         * - Makes less assumptions about the structure in the Product being unchanging over time. In
+         *   particular, the Feature codes are included in the data, so that changes to what Features
+         *   are used in a Product is less likely to lead to unexpected results.
+         * - You can request ExtendedData and/or ProductParams to be included in the result. This extra
+         *   data is ignored when passed back into the API, but it can be very useful for external
+         *   applications.
+         * The other version (getApiSelection) has the advantage of using a format directly compatible with the API:s.
+         * @param includeExtendedData  Includes extra data which is not an actual part of the configuration,
+         *                             i.e. units and groupCodes
+         * @param includeProductParams Includes what Product this was generated for, and the same for any
+         *                             Additional Products.
          */
-        this.getApiSelection = () => convertDtoConfProdToV1(this._internal.getDtoConf(false, false), true);
         this.getDtoConf = (includeExtendedData = false, includeProductParams = false) => this._internal.getDtoConf(includeExtendedData, includeProductParams);
-        this.setDtoConf = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConf(s, doValidate); });
-        this.setApiSelection = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(s, doValidate); });
+        /**
+         * A newer alternative version of setApiSelection.
+         * @param doValidate Makes a server side validation call. These are necessary to ensure that
+         *                   the right models are loaded.
+         */
+        this.setDtoConf = (configuration, doValidate = true) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setDtoConf(configuration, doValidate); });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
         this.stopAllListenForChange = () => this._internal.changeObservable.stopAllListen();
@@ -731,6 +817,21 @@ export class CfgProduct {
     get visible() {
         return this._internal.visible;
     }
+    // A similar text to the one below exists in global-message-managers.md and should be kept in sync.
+    /**
+     * Functional selection is a Catalogues feature where selecting Options on Features result in that you
+     * "jump" to another Product as a result of the Validate call. You normally do not notice that a functional
+     * selection has occurred except for the styleNr changing. Functional selection can change which Features
+     * from the original product call are used as root Features. This can in turn affect if serialized
+     * configuration can be applied or not.
+     *
+     * The SDK can currently only apply serialized configuration if the list of root Features has not changed.
+     * For this reason, when functional selection has happened, extracting data for external systems might work
+     * well, but reapplying back into Stage will probably fail.
+     */
+    get hasRootFeaturesChanged() {
+        return this._internal.hasRootFeaturesChanged;
+    }
     get rawProductData() {
         return this._internal.rawProductData;
     }

package/dist/CfgReferencePathHelper.d.ts

@@ -1,4 +1,4 @@
-import { DtoCatalogueParamsWithLang, DtoProductParamsWithLang } from "./CatalogueAPI";
+import { DtoCatalogueParamsWithCidAndLang, DtoProductParamsWithCidAndLang } from "./CatalogueAPI";
 /**
  * These methods aims to provide a default suggested way of building
  * URLs to Products and Catalogues. By using consistent URL:s copy-paste
@@ -8,7 +8,20 @@ import { DtoCatalogueParamsWithLang, DtoProductParamsWithLang } from "./Catalogu
  * Internally at Configura we try to stick with this format.
  */
 export declare class CfgReferencePathHelper {
-    static getCataloguePath: (browsingRootUrl: string, catParams: DtoCatalogueParamsWithLang) => string;
-    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithLang) => string;
+    /**
+     * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+     * @param browsingRootUrl The URL where Stage browsing begins
+     * @param catParams What catalogue to generate URL for.
+     * @returns An URL to a catalogue
+     */
+    static getCataloguePath: (browsingRootUrl: string, catParams: DtoCatalogueParamsWithCidAndLang) => string;
+    /**
+     * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+     * @param browsingRootUrl The URL where Stage browsing begins
+     * @param productParams What product to generate URL for.
+     * @param separator Optional, defaults to "product", but can be changed to indicate another function.
+     * @returns An URL to a product
+     */
+    static getProductPath: (browsingRootUrl: string, productParams: DtoProductParamsWithCidAndLang, separator?: string) => string;
 }
 //# sourceMappingURL=CfgReferencePathHelper.d.ts.map

package/dist/CfgReferencePathHelper.js

@@ -9,5 +9,18 @@ import { encodeURIComponents } from "@configura/web-utilities";
  */
 export class CfgReferencePathHelper {
 }
+/**
+ * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+ * @param browsingRootUrl The URL where Stage browsing begins
+ * @param catParams What catalogue to generate URL for.
+ * @returns An URL to a catalogue
+ */
 CfgReferencePathHelper.getCataloguePath = (browsingRootUrl, catParams) => `${browsingRootUrl}/${encodeURIComponents(catParams.cid, catParams.lang, catParams.enterprise, catParams.prdCat, catParams.prdCatVersion, catParams.vendor, catParams.priceList)}`;
-CfgReferencePathHelper.getProductPath = (browsingRootUrl, productParams) => `${CfgReferencePathHelper.getCataloguePath(browsingRootUrl, productParams)}/product/${encodeURIComponent(productParams.partNumber)}`;
+/**
+ * Use to generate URLs in our reference format. This is the format Configura uses in our integrations.
+ * @param browsingRootUrl The URL where Stage browsing begins
+ * @param productParams What product to generate URL for.
+ * @param separator Optional, defaults to "product", but can be changed to indicate another function.
+ * @returns An URL to a product
+ */
+CfgReferencePathHelper.getProductPath = (browsingRootUrl, productParams, separator = "product") => `${CfgReferencePathHelper.getCataloguePath(browsingRootUrl, productParams)}/${separator}/${encodeURIComponent(productParams.partNumber)}`;

package/dist/ConfigurationConverter.d.ts

@@ -1,5 +1,14 @@
-import { DtoAdditionalProductConfiguration, DtoConfAddProd, DtoConfFeature, DtoConfProd, DtoSelectedOption } from "./CatalogueAPI.js";
-export declare const isDtoConfProdAdditional: (value: DtoConfProd) => value is DtoConfAddProd;
-export declare const convertDtoConfProdToV1: (conf: DtoConfProd, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
-export declare const convertDtoConfFeaturesToSelOptions: (features: DtoConfFeature[], silenceWarnings?: boolean) => DtoSelectedOption[];
+import { DtoAdditionalProductConf, DtoAdditionalProductConfiguration, DtoFeatureConf, DtoProductConf, DtoSelectedOption } from "./CatalogueAPI.js";
+export declare const isDtoProductConfAdditional: (value: DtoProductConf) => value is DtoAdditionalProductConf;
+export declare const convertDtoProductConfToV1: (conf: DtoProductConf, silenceWarnings?: boolean) => DtoAdditionalProductConfiguration;
+export declare const convertDtoFeatureConfsToSelOptions: (features: DtoFeatureConf[], silenceWarnings?: boolean) => DtoSelectedOption[];
+/**
+ * Serializes and compacts the configuration into a format especially suited for URLs
+ */
+export declare const dtoProductConfigurationToCompactString: (conf: DtoProductConf) => string;
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export declare const compactStringToDtoProductConf: (versionAndConf: string) => DtoProductConf;
+export declare const stripExtendedDataFromDtoProductConf: (conf: DtoProductConf) => DtoProductConf;
 //# sourceMappingURL=ConfigurationConverter.d.ts.map

package/dist/ConfigurationConverter.js

@@ -1,33 +1,33 @@
-export const isDtoConfProdAdditional = (value) => "refKey" in value;
+export const isDtoProductConfAdditional = (value) => "refKey" in value;
 // As this has potential to flood the terminal we only inform once
 let hasInformedAboutProdParams = false;
 let hasInformedAboutGroupCode = false;
 let hasInformedAboutUnit = false;
-export const convertDtoConfProdToV1 = (conf, silenceWarnings = false) => {
+export const convertDtoProductConfToV1 = (conf, silenceWarnings = false) => {
     var _a, _b;
     if (!silenceWarnings && conf.prodParams !== undefined && !hasInformedAboutProdParams) {
         hasInformedAboutProdParams = true;
-        console.info("Incoming DtoProductConfiguration contains prodParams. These will be ignored.");
+        console.info("Incoming DtoProductConf contains prodParams. These will be ignored.");
     }
     const result = {
         selOptions: ((_a = conf.features) !== null && _a !== void 0 ? _a : []).map((f) => ({
             code: "!~!",
-            next: convertDtoConfFeatureToApiSelection(f, silenceWarnings),
+            next: convertDtoFeatureConfToApiSelection(f, silenceWarnings),
         })),
-        additionalProducts: ((_b = conf.additionalProducts) !== null && _b !== void 0 ? _b : []).map((p) => convertDtoConfProdToV1(p, silenceWarnings)),
+        additionalProducts: ((_b = conf.additionalProducts) !== null && _b !== void 0 ? _b : []).map((p) => convertDtoProductConfToV1(p, silenceWarnings)),
         selected: true,
     };
-    if (isDtoConfProdAdditional(conf)) {
+    if (isDtoProductConfAdditional(conf)) {
         result.refKey = conf.refKey;
         result.selected = conf.selected;
     }
     return result;
 };
-export const convertDtoConfFeaturesToSelOptions = (features, silenceWarnings = false) => (features !== null && features !== void 0 ? features : []).map((f) => ({
+export const convertDtoFeatureConfsToSelOptions = (features, silenceWarnings = false) => (features !== null && features !== void 0 ? features : []).map((f) => ({
     code: "!~!",
-    next: convertDtoConfFeatureToApiSelection(f, silenceWarnings),
+    next: convertDtoFeatureConfToApiSelection(f, silenceWarnings),
 }));
-const convertDtoConfFeatureToApiSelection = (feature, silenceWarnings) => {
+const convertDtoFeatureConfToApiSelection = (feature, silenceWarnings) => {
     const { groupCode, options, unit } = feature;
     if (!silenceWarnings && groupCode !== undefined && !hasInformedAboutGroupCode) {
         hasInformedAboutGroupCode = true;
@@ -39,13 +39,13 @@ const convertDtoConfFeatureToApiSelection = (feature, silenceWarnings) => {
     }
     const result = {};
     for (const option of (options !== null && options !== void 0 ? options : []).filter((o) => o.selected)) {
-        result[option.code] = convertDtoConfOptionToSelectedOption(option, silenceWarnings);
+        result[option.code] = convertDtoOptionConfToSelectedOption(option, silenceWarnings);
     }
     return result;
 };
-const convertDtoConfOptionToSelectedOption = (option, silenceWarnings) => {
+const convertDtoOptionConfToSelectedOption = (option, silenceWarnings) => {
     const { features, code, numericValue } = option;
-    const selectionTrees = (features !== null && features !== void 0 ? features : []).map((f) => convertDtoConfFeatureToApiSelection(f, silenceWarnings));
+    const selectionTrees = (features !== null && features !== void 0 ? features : []).map((f) => convertDtoFeatureConfToApiSelection(f, silenceWarnings));
     const mergedSelectionTree = {};
     let anyItems = false;
     for (const selectionTree of selectionTrees) {
@@ -70,3 +70,97 @@ const convertDtoConfOptionToSelectedOption = (option, silenceWarnings) => {
     }
     return selectedOption;
 };
+const versionedRegex = /^v(\d+)(.+)$/;
+const jsonKeyRegex = /"([^"]+)":/g;
+const swapForUrlAdaptedRegex = /[-~_{}"]/g;
+const shortToLong = new Map();
+const longToShort = new Map();
+// The replacement scheme here assumes this will only be used for keys
+// in DtoProductConf and the knowledge that it contains no one
+// one char keys.
+for (const [long, short] of [
+    ["configuration", "c"],
+    ["additionalProducts", "a"],
+    ["prodParams", "p"],
+    ["refKey", "r"],
+    ["selected", "s"],
+    ["features", "f"],
+    ["code", "d"],
+    ["options", "o"],
+    ["numericValue", "n"],
+    ["groupCode", "g"],
+    ["unit", "u"],
+]) {
+    shortToLong.set(short, long);
+    longToShort.set(long, short);
+}
+/**
+ * As certain chars are abundant in JSON but less abundant in the actual data
+ * we swap these so that frequent characters do not need to be URL-encoded.
+ */
+const jsonStringSwapCharsForUrl = (data) => data.replace(swapForUrlAdaptedRegex, (char) => {
+    switch (char) {
+        case "{":
+            return "~";
+        case "}":
+            return "-";
+        case '"':
+            return "_";
+        case "~":
+            return "{";
+        case "-":
+            return "}";
+        case "_":
+            return '"';
+        default:
+            throw new Error(`Unexpected char "${char}" in swap for URL`);
+    }
+});
+const compactDtoProductConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = longToShort.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+const expandDtoProductConfJsonKeys = (data) => data.replace(jsonKeyRegex, (_, key) => { var _a; return `"${(_a = shortToLong.get(key)) !== null && _a !== void 0 ? _a : key}":`; });
+/**
+ * Serializes and compacts the configuration into a format especially suited for URLs
+ */
+export const dtoProductConfigurationToCompactString = (conf) => "v1" +
+    jsonStringSwapCharsForUrl(compactDtoProductConfJsonKeys(JSON.stringify(conf, undefined, "")));
+/**
+ * Deserializes and inflates the configuration from the compacted format
+ */
+export const compactStringToDtoProductConf = (versionAndConf) => {
+    const match = versionedRegex.exec(versionAndConf);
+    if (match === null) {
+        throw new Error("Could not match version string");
+    }
+    const [, version, conf] = match;
+    if (version !== "1") {
+        throw new Error("Unknown packed URL version");
+    }
+    if (conf === "") {
+        throw new Error("No conf found");
+    }
+    return JSON.parse(expandDtoProductConfJsonKeys(jsonStringSwapCharsForUrl(conf)));
+};
+export const stripExtendedDataFromDtoProductConf = (conf) => {
+    var _a, _b;
+    return ({
+        features: (_a = conf.features) === null || _a === void 0 ? void 0 : _a.map(stripExtendedDataFromDtoFeatureConf),
+        additionalProducts: (_b = conf.additionalProducts) === null || _b === void 0 ? void 0 : _b.map(stripExtendedDataFromDtoAdditionalProductConfiguration),
+    });
+};
+const stripExtendedDataFromDtoAdditionalProductConfiguration = (conf) => (Object.assign(Object.assign({}, stripExtendedDataFromDtoProductConf(conf)), { refKey: conf.refKey, selected: conf.selected }));
+const stripExtendedDataFromDtoFeatureConf = (conf) => {
+    var _a;
+    return ({
+        code: conf.code,
+        options: (_a = conf.options) === null || _a === void 0 ? void 0 : _a.map(stripExtendedDataFromDtoOptionConf),
+    });
+};
+const stripExtendedDataFromDtoOptionConf = (conf) => {
+    var _a;
+    return ({
+        code: conf.code,
+        selected: conf.selected,
+        numericValue: conf.numericValue,
+        features: (_a = conf.features) === null || _a === void 0 ? void 0 : _a.map(stripExtendedDataFromDtoFeatureConf),
+    });
+};

package/dist/io/CfgHistoryManager.d.ts

@@ -2,25 +2,57 @@ import { CfgWindowEventManager } from "./CfgWindowEventManager.js";
 declare type CfgHistoryManagerMessageData = {
     initial: boolean;
 };
+/**
+ * How the history is updated.
+ * @param DoNotWrite Only listens to initial URL-values.
+ * @param Replace Replaces the current history frame at updates.
+ * @param Push Adds history frames at updates.
+ * @param ReplaceAndUpdateUrl Replaces the current history frame at updates and updates the browser URL
+ * @param PushAndUpdateUrl Adds history frames at updates and updates the browser URL
+ */
+export declare enum HistoryMode {
+    DoNotWrite = 0,
+    Replace = 1,
+    Push = 2,
+    ReplaceAndUpdateUrl = 3,
+    PushAndUpdateUrl = 4
+}
 /**
  * The collected data used when sending. For history this both contains the message, which is
- * used as the "state" in the history-frame, and the qsKeyValues, which are used in the URL.
+ * used as the "state" in the history-frame, and the qsKeyValues, which are query string
+ * key-values used in the URL.
  * When navigating back and forth the stage (message) is used to restore the old state. When
  * opening a window with no prior history the Query String will be used.
  */
 export declare type CfgHistoryManagerSendData<D> = {
     message: D;
-    useHistoryPush: boolean;
+    mode: HistoryMode;
     qsKeyValues: Map<string, string | undefined>;
 };
 /**
- * This class does nothing on it's own. It is used to coordinate writing to the history, that
- * is, updating the browsing history.
+ * This class is used to coordinate writing and reading to the browser history.
+ * It handles messages sent from the connectors.
  */
 export declare class CfgHistoryManager extends CfgWindowEventManager<"popstate", CfgHistoryManagerSendData<CfgHistoryManagerMessageData>> {
     private static _instance;
     static get instance(): CfgHistoryManager;
     private constructor();
+    private _aggregatedQsKeyValues;
+    private _urlUpdateObservable;
+    /**
+     * @returns The current browser URL updated with the latest updates from
+     *          the Connectors.
+     */
+    getUrl(): string;
+    /**
+     * Listen for updated URL:s. This doesn't have to mean the URL in the
+     * browser has been updated.
+     */
+    listenForUrl(listener: (url: string) => void): void;
+    /**
+     * Stop listen.
+     */
+    stopListenForUrl(listener: (url: string) => void): void;
     /**
      * Write to the history
      */
@@ -46,6 +78,7 @@ export declare class CfgHistoryManager extends CfgWindowEventManager<"popstate",
     private static _makeUpdatedState;
     protected readonly eventType = "popstate";
     protected getDataFromEvent(event: PopStateEvent): unknown;
+    static getMessageFromCurrentHistoryState(messageKey: string): unknown | undefined;
 }
 export {};
 //# sourceMappingURL=CfgHistoryManager.d.ts.map