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

package/dist/CatalogueAPI.d.ts

@@ -80,8 +80,9 @@ export interface ErrorResponse {
     code: number;
     eventId?: string;
 }
-/** ExportFormat - The values must be the file extension used by each format. */
-export declare type ExportFormat = "fbx" | "dwg" | "cmdrw" | "cmfav" | "cmsym";
+/** ExportFormat - Format of the exported product, identical to the format's file extension. */
+export declare type ExportFormat = "glb" | "gltf" | "fbx" | "dwg" | "cmdrw" | "cmfav" | "cmsym";
+export declare const exportFormatNames: ExportFormat[];
 /** ExportRequest */
 export interface ExportRequest {
     format: ExportFormat;
@@ -102,6 +103,7 @@ export interface ExportStatus {
 }
 /** ExportStatusStatus - WIP */
 export declare type ExportStatusStatus = "pending" | "running" | "finished" | "failed";
+export declare const exportStatusStatusNames: ExportStatusStatus[];
 /** Feature */
 export interface Feature {
     code: string;
@@ -338,6 +340,8 @@ export interface ProductData {
     depth?: string;
     description?: string;
     height?: string;
+    hideIfMainProduct?: boolean;
+    hideIfAdditionalProduct?: boolean;
     length?: string;
     mtrlApplications?: Array<MtrlApplication>;
     additionalProductRefs?: Array<AdditionalProductRef>;
@@ -379,6 +383,7 @@ export interface RefreshSessionTokenResponse {
 }
 /** RenderFormat */
 export declare type RenderFormat = "jpg" | "png";
+export declare const renderFormatNames: RenderFormat[];
 /** RenderRequest */
 export interface RenderRequest {
     width: number;
@@ -402,6 +407,7 @@ export interface RenderStatus {
 }
 /** RenderStatusStatus - WIP */
 export declare type RenderStatusStatus = "pending" | "running" | "finished" | "failed";
+export declare const renderStatusStatusNames: RenderStatusStatus[];
 /** SelectedOption */
 export interface SelectedOption {
     code: string;
@@ -422,6 +428,7 @@ export interface SyncGroup {
 }
 /** SyncGroupMethods */
 export declare type SyncGroupMethods = "pull" | "push" | "twoWay";
+export declare const syncGroupMethodsNames: SyncGroupMethods[];
 /** TargetCameraArgs */
 export interface TargetCameraArgs {
     location?: Point;

package/dist/CatalogueAPI.js

@@ -9,6 +9,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+export const exportFormatNames = [
+    "glb",
+    "gltf",
+    "fbx",
+    "dwg",
+    "cmdrw",
+    "cmfav",
+    "cmsym",
+];
+export const exportStatusStatusNames = [
+    "pending",
+    "running",
+    "finished",
+    "failed",
+];
+export const renderFormatNames = ["jpg", "png"];
+export const renderStatusStatusNames = [
+    "pending",
+    "running",
+    "finished",
+    "failed",
+];
+export const syncGroupMethodsNames = ["pull", "push", "twoWay"];
 export class APIError extends Error {
 }
 export class CatalogueAPI {

package/dist/CfgMeasure.d.ts

@@ -1,4 +1,4 @@
-import { Measurement, ValueWithUnit } from "./CatalogueAPI";
+import { Measurement, ValueWithUnit } from "./CatalogueAPI.js";
 /**
  * Measures can be used to Anchor items (Models or Additional Products).
  *
@@ -19,7 +19,7 @@ export declare type CfgMeasurePriority = {
 };
 /**
  * This class strips the Measurement of things that are not actually used or relevant
- * to Stage, specifically anchoring and stretching. Measurments can also contain
+ * to Stage, specifically anchoring and stretching. Measurements can also contain
  * volume and area, but these are ignored. Here Measures are used to define defaults
  * such as its preferences when dealing with ambiguity or its default value.
  */

package/dist/CfgMeasure.js

@@ -1,6 +1,6 @@
 /**
  * This class strips the Measurement of things that are not actually used or relevant
- * to Stage, specifically anchoring and stretching. Measurments can also contain
+ * to Stage, specifically anchoring and stretching. Measurements can also contain
  * volume and area, but these are ignored. Here Measures are used to define defaults
  * such as its preferences when dealing with ambiguity or its default value.
  */

package/dist/CfgProduct.d.ts

@@ -8,6 +8,7 @@ import { ProductLoader } from "./productLoader.js";
 import { CfgProductData, RootNodeSource } from "./utilitiesCatalogueData.js";
 export declare type CfgProductChangeNotification = {
     freshRef: CfgProduct;
+    committed: boolean;
 };
 export declare type CfgProductSettings = {
     /**
@@ -97,15 +98,32 @@ export declare class _CfgProductInternal {
     setSelected(v: boolean, bubbleMode: CfgProductBubbleMode): Promise<boolean>;
     get configuration(): CfgProductConfiguration;
     get rawProductData(): CfgProductData;
-    _notifyAllOfChange: (bubbleMode: CfgProductBubbleMode) => Promise<void>;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visibleIfAdditionalProduct(): boolean;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visibleIfMainProduct(): boolean;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visible(): boolean;
+    _notifyAllOfChange: (bubbleMode: CfgProductBubbleMode, committed: boolean) => Promise<void>;
     /** Called when a child (additional product or the configuration) has changed. */
     private _childHasChanged;
     /** Called by child to tell its parent that it has changed. */
-    _additionalProductHasChanged: (freshRef: CfgProduct, bubbleMode: CfgProductBubbleMode) => Promise<void>;
+    _additionalProductHasChanged: (freshRef: CfgProduct, bubbleMode: CfgProductBubbleMode, committed: boolean) => Promise<void>;
     /** Called by the configuration to tell its parent that it has changed. */
-    _configurationHasChanged: (freshRef: CfgProductConfiguration, bubbleMode: ProductConfigurationBubbleMode) => Promise<void>;
+    _configurationHasChanged: (freshRef: CfgProductConfiguration, bubbleMode: ProductConfigurationBubbleMode, committed: boolean) => Promise<void>;
     getApiSelection: () => AdditionalProductConfiguration;
     setApiSelection: (s: AdditionalProductConfiguration, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
+    getApiSelectionAsString: () => string;
+    setFromApiSelectionString: (str: string, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     structureCompare: (other: _CfgProductInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
     tryMatchSelection: (other: _CfgProductInternal, descriptionMatch?: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     /** Only features in selected options and selected additional products. */
@@ -116,7 +134,7 @@ export declare class _CfgProductInternal {
      * product in isolation. The validation result is applied on the configuration. Then additional
      * products are synced (unloaded, loaded etc.) Finally the changes bubble up the tree.
      */
-    _revalidate: (bubbleMode: CfgProductBubbleMode, productLoader: ProductLoader) => Promise<boolean>;
+    _revalidate: (bubbleMode: CfgProductBubbleMode, productLoader: ProductLoader, committed: boolean) => Promise<boolean>;
     /**
      * Based on this configuration find what additional products should be shown and not, unload
      * (i.e. destroy) those that should no longer be shown, load the new ones.
@@ -163,6 +181,13 @@ export declare class CfgProduct {
      * always true.
      */
     get selected(): boolean;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     * Visibility is affects the Configuration for this Product, but any Additional Products
+     * will not be affected.
+     */
+    get visible(): boolean;
     /**
      * Only applicable when this product is optional.
      * Setting this does not cause a validation call as toggling an optional additional product is
@@ -208,6 +233,8 @@ export declare class CfgProduct {
      */
     getApiSelection: () => AdditionalProductConfiguration;
     setApiSelection: (s: AdditionalProductConfiguration, doValidate?: boolean) => Promise<boolean>;
+    getApiSelectionAsString: () => string;
+    setFromApiSelectionString: (str: string, doValidate?: boolean) => Promise<boolean>;
     listenForChange: (l: SingleArgCallback<CfgProductChangeNotification>) => void;
     stopListenForChange: (l: SingleArgCallback<CfgProductChangeNotification>) => void;
     stopAllListenForChange: () => void;

package/dist/CfgProduct.js

@@ -76,31 +76,31 @@ export class _CfgProductInternal {
                 additionalProduct.destroy();
             }
         };
-        this._notifyAllOfChange = (bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+        this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             if (bubbleMode === CfgProductBubbleMode.Stop) {
                 return;
             }
             const parent = this.parent;
             const freshRef = CfgProduct._makeNewRefFrom(this);
-            this.changeObservable.notifyAll({ freshRef });
+            this.changeObservable.notifyAll({ freshRef, committed });
             if (parent !== undefined) {
                 yield parent._additionalProductHasChanged(freshRef, bubbleMode === CfgProductBubbleMode.OneLevel
                     ? CfgProductBubbleMode.Stop
-                    : bubbleMode);
+                    : bubbleMode, committed);
             }
         });
         /** Called when a child (additional product or the configuration) has changed. */
-        this._childHasChanged = (bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+        this._childHasChanged = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             if (bubbleMode === CfgProductBubbleMode.ToRootAndBubbleSelected &&
                 this.optional &&
                 !this.selected) {
                 yield this.setSelected(true, bubbleMode);
                 return;
             }
-            yield this._notifyAllOfChange(bubbleMode);
+            yield this._notifyAllOfChange(bubbleMode, committed);
         });
         /** Called by child to tell its parent that it has changed. */
-        this._additionalProductHasChanged = (freshRef, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+        this._additionalProductHasChanged = (freshRef, bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             const i = this.additionalProducts.findIndex((a) => a.isBackedBySame(freshRef));
             if (i !== -1) {
                 // Child additional product might not be found. This probably means that propagate
@@ -110,31 +110,31 @@ export class _CfgProductInternal {
                 // C no longer is part of the tree. Odd, but fully permitted.
                 this.additionalProducts[i] = freshRef;
             }
-            yield this._childHasChanged(bubbleMode);
+            yield this._childHasChanged(bubbleMode, committed);
         });
         /** Called by the configuration to tell its parent that it has changed. */
-        this._configurationHasChanged = (freshRef, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+        this._configurationHasChanged = (freshRef, bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             this._configuration = freshRef;
             switch (bubbleMode) {
                 case ProductConfigurationBubbleMode.ValidateAndBubbleSelected:
                     // The revalidate call will continue the bubble
-                    yield this._revalidate(CfgProductBubbleMode.ToRootAndBubbleSelected, this._productLoaderRaw);
+                    yield this._revalidate(CfgProductBubbleMode.ToRootAndBubbleSelected, this._productLoaderRaw, committed);
                     return;
                 case ProductConfigurationBubbleMode.Validate:
                     // The revalidate call will continue the bubble
-                    yield this._revalidate(CfgProductBubbleMode.ToRoot, this._productLoaderRaw);
+                    yield this._revalidate(CfgProductBubbleMode.ToRoot, this._productLoaderRaw, committed);
                     return;
                 case ProductConfigurationBubbleMode.ToParentProduct:
                     // Do not continue bubble as we have reached the parent CfgProduct
                     return;
                 case ProductConfigurationBubbleMode.OneLevel:
-                    yield this._childHasChanged(CfgProductBubbleMode.OneLevel);
+                    yield this._childHasChanged(CfgProductBubbleMode.OneLevel, committed);
                     return;
                 case ProductConfigurationBubbleMode.Stop:
-                    yield this._childHasChanged(CfgProductBubbleMode.Stop);
+                    yield this._childHasChanged(CfgProductBubbleMode.Stop, committed);
                     return;
                 case ProductConfigurationBubbleMode.ToRoot:
-                    yield this._childHasChanged(CfgProductBubbleMode.ToRoot);
+                    yield this._childHasChanged(CfgProductBubbleMode.ToRoot, committed);
                     return;
             }
         });
@@ -180,16 +180,20 @@ export class _CfgProductInternal {
                 change = true;
             }
             if (doValidate && configurationChange) {
-                yield this._revalidate(CfgProductBubbleMode.ToRoot, productLoaderForGroupedLoad);
+                yield this._revalidate(CfgProductBubbleMode.ToRoot, productLoaderForGroupedLoad, true);
             }
             else if (change) {
                 // As setApiSelection is done recursively each level takes care of its own notifications
                 // so we only need to bubble one level to notify this and swap out the reference in the
                 // parent.
-                yield this._notifyAllOfChange(CfgProductBubbleMode.OneLevel);
+                yield this._notifyAllOfChange(CfgProductBubbleMode.OneLevel, true);
             }
             return change;
         });
+        this.getApiSelectionAsString = () => JSON.stringify(this.getApiSelection(), undefined, "");
+        this.setFromApiSelectionString = (str, doValidate, productLoaderForGroupedLoad) => __awaiter(this, void 0, void 0, function* () {
+            return this.setApiSelection(JSON.parse(decodeURIComponent(str)), doValidate, productLoaderForGroupedLoad);
+        });
         this.structureCompare = (other, strictOrder = true, descriptionMatch = false) => {
             if (!this.configuration.structureCompare(other.configuration, strictOrder, descriptionMatch)) {
                 return false;
@@ -212,10 +216,10 @@ export class _CfgProductInternal {
             const configurationChange = yield this.configuration._internal.tryMatchSelection(other.configuration._internal, descriptionMatch, false);
             if (configurationChange) {
                 change = true;
-                yield this._revalidate(CfgProductBubbleMode.ToRootAndBubbleSelected, productLoaderForGroupedLoad);
+                yield this._revalidate(CfgProductBubbleMode.ToRootAndBubbleSelected, productLoaderForGroupedLoad, true);
             }
             else if (change) {
-                yield this._notifyAllOfChange(CfgProductBubbleMode.ToRootAndBubbleSelected);
+                yield this._notifyAllOfChange(CfgProductBubbleMode.ToRootAndBubbleSelected, true);
             }
             const thisAdditionalProducts = this.additionalProducts;
             const otherAdditionalProducts = other.additionalProducts;
@@ -264,7 +268,7 @@ export class _CfgProductInternal {
          * product in isolation. The validation result is applied on the configuration. Then additional
          * products are synced (unloaded, loaded etc.) Finally the changes bubble up the tree.
          */
-        this._revalidate = (bubbleMode, productLoader) => __awaiter(this, void 0, void 0, function* () {
+        this._revalidate = (bubbleMode, productLoader, committed) => __awaiter(this, void 0, void 0, function* () {
             const { _configuration: configuration } = this;
             const token = this.loadingObservable.startChildLoading();
             this._revalidateInProgressToken = token;
@@ -303,7 +307,7 @@ export class _CfgProductInternal {
                 if (this._destroyed) {
                     return false;
                 }
-                yield this._notifyAllOfChange(bubbleMode);
+                yield this._notifyAllOfChange(bubbleMode, committed);
                 return true;
             }
             catch (e) {
@@ -461,7 +465,7 @@ export class _CfgProductInternal {
                 return false;
             }
             this._selected = v;
-            yield this._notifyAllOfChange(bubbleMode);
+            yield this._notifyAllOfChange(bubbleMode, true);
             return true;
         });
     }
@@ -471,6 +475,29 @@ export class _CfgProductInternal {
     get rawProductData() {
         return this._rawProductData;
     }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visibleIfAdditionalProduct() {
+        return this.rawProductData.hideIfAdditionalProduct !== true;
+    }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visibleIfMainProduct() {
+        return this.rawProductData.hideIfMainProduct !== true;
+    }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
+    get visible() {
+        return this.isAdditionalProduct
+            ? this.visibleIfAdditionalProduct
+            : this.visibleIfMainProduct;
+    }
 }
 _CfgProductInternal.make = (productLoaderRaw, productLoaderForGroupedLoad, // Used when instantiating the current product
 lang, catId, partNumber, settings, optional, loadingObservable, refKey, refDescription, parent, root, transform, anchor) => __awaiter(void 0, void 0, void 0, function* () {
@@ -531,6 +558,8 @@ export class CfgProduct {
          */
         this.getApiSelection = () => this._internal.getApiSelection();
         this.setApiSelection = (s, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setApiSelection(s, doValidate); });
+        this.getApiSelectionAsString = () => this._internal.getApiSelectionAsString();
+        this.setFromApiSelectionString = (str, doValidate = false) => __awaiter(this, void 0, void 0, function* () { return yield this._internal.setFromApiSelectionString(str, doValidate); });
         this.listenForChange = (l) => this._internal.changeObservable.listen(l);
         this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
         this.stopAllListenForChange = () => this._internal.changeObservable.stopAllListen();
@@ -589,6 +618,15 @@ export class CfgProduct {
     get selected() {
         return this._internal.selected;
     }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     * Visibility is affects the Configuration for this Product, but any Additional Products
+     * will not be affected.
+     */
+    get visible() {
+        return this._internal.visible;
+    }
     get rawProductData() {
         return this._internal.rawProductData;
     }

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export * from "./CatalogueAPI.js";
 export * from "./CfgProduct.js";
+export * from "./io/CfgHistoryManager.js";
+export * from "./io/CfgHistoryToProdConfConnector.js";
+export * from "./io/CfgWindowMessageManager.js";
+export * from "./io/CfgWindowMessageToProdConfConnector.js";
 export * from "./material/CfgMaterialMapping.js";
 export * from "./material/CfgMtrlApplication.js";
 export * from "./material/CfgMtrlApplicationSource.js";

package/dist/index.js

@@ -1,5 +1,9 @@
 export * from "./CatalogueAPI.js";
 export * from "./CfgProduct.js";
+export * from "./io/CfgHistoryManager.js";
+export * from "./io/CfgHistoryToProdConfConnector.js";
+export * from "./io/CfgWindowMessageManager.js";
+export * from "./io/CfgWindowMessageToProdConfConnector.js";
 export * from "./material/CfgMaterialMapping.js";
 export * from "./material/CfgMtrlApplication.js";
 export * from "./material/CfgMtrlApplicationSource.js";

package/dist/io/CfgHistoryManager.d.ts

@@ -0,0 +1,30 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgHistoryManagerSendData<D> = {
+    message: D;
+    qsKeyValues: Map<string, string | undefined>;
+};
+/**
+ * Instantiating the class will use the history api to update your
+ * url with configuration changes
+ * Only handles configuration, not product
+ */
+export declare class CfgHistoryManager<D extends {
+    initial: boolean;
+}> extends CfgIOManager<"popstate", CfgHistoryManagerSendData<D>> {
+    private readonly _useHistoryPush;
+    /**
+     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     */
+    constructor(_useHistoryPush: boolean);
+    protected doSend(messageKey: string, data: CfgHistoryManagerSendData<D>): void;
+    private static _makeUpdatedUrl;
+    private static _makeUpdatedQueryString;
+    /**
+     * @returns The current query string as a Map
+     */
+    static _currentQsKeyValues(): Map<string, string>;
+    private static _makeUpdatedState;
+    protected readonly eventType = "popstate";
+    protected getDataFromEvent(event: PopStateEvent): unknown;
+}
+//# sourceMappingURL=CfgHistoryManager.d.ts.map

package/dist/io/CfgHistoryManager.js

@@ -0,0 +1,62 @@
+import { mapQueryString, unmapQueryString } from "@configura/web-utilities";
+import { CfgIOManager } from "./CfgIOManager.js";
+/**
+ * Instantiating the class will use the history api to update your
+ * url with configuration changes
+ * Only handles configuration, not product
+ */
+export class CfgHistoryManager extends CfgIOManager {
+    /**
+     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     */
+    constructor(_useHistoryPush) {
+        super();
+        this._useHistoryPush = _useHistoryPush;
+        this.eventType = "popstate";
+    }
+    doSend(messageKey, data) {
+        const { qsKeyValues, message } = data;
+        const newUrl = CfgHistoryManager._makeUpdatedUrl(qsKeyValues);
+        const newState = CfgHistoryManager._makeUpdatedState(message, messageKey);
+        if (!message.initial && this._useHistoryPush) {
+            window.history.pushState(newState, "", newUrl);
+        }
+        else {
+            window.history.replaceState(newState, "", newUrl);
+        }
+    }
+    static _makeUpdatedUrl(qsKeyValues) {
+        const qs = this._makeUpdatedQueryString(qsKeyValues);
+        return `${window.location.origin}${window.location.pathname}${qs ? "?" : ""}${qs}${window.location.hash}`;
+    }
+    static _makeUpdatedQueryString(qsKeyValues) {
+        const currentKeyValues = this._currentQsKeyValues();
+        for (const [key, value] of qsKeyValues) {
+            if (value === undefined) {
+                currentKeyValues.delete(key);
+            }
+            else {
+                currentKeyValues.set(key, value);
+            }
+        }
+        return unmapQueryString(currentKeyValues);
+    }
+    /**
+     * @returns The current query string as a Map
+     */
+    static _currentQsKeyValues() {
+        return mapQueryString(window.location.search);
+    }
+    static _makeUpdatedState(message, messageKey) {
+        let messages = {};
+        const currentState = window.history.state;
+        if (CfgIOManager.isIOContainer(currentState)) {
+            messages = currentState.messages;
+        }
+        messages[messageKey] = message;
+        return CfgIOManager.makeContainer(messages);
+    }
+    getDataFromEvent(event) {
+        return event.state;
+    }
+}

package/dist/io/CfgHistoryToProdConfConnector.d.ts

@@ -0,0 +1,10 @@
+import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
+export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
+export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector<"popstate", CfgHistoryManagerSendData<CfgProdConfMessage>, CfgHistoryManager<CfgProdConfMessage>> {
+    private readonly _qsKey;
+    constructor(manager: CfgHistoryManager<CfgProdConfMessage>, _qsKey?: string, doValidate?: boolean);
+    protected getInitialProdConf(): string | undefined;
+    protected makeSendData(prodConfAsString: string, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
+}
+//# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

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

package/dist/io/CfgIOManager.d.ts

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

package/dist/io/CfgIOManager.js

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

package/dist/io/CfgIOProdConfConnector.d.ts

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

package/dist/io/CfgIOProdConfConnector.js

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

package/dist/io/CfgWindowMessageManager.d.ts

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

package/dist/io/CfgWindowMessageManager.js

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

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

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

package/dist/io/CfgWindowMessageToProdConfConnector.js

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

package/dist/productConfiguration/CfgFeature.d.ts

@@ -66,8 +66,20 @@ export declare class _CfgFeatureInternal {
      */
     private get isAllOptionsAffectedByAnySelection();
     get preview(): string | undefined;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visibleIfAdditionalProduct(): boolean;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visibleIfMainProduct(): boolean;
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visible(): boolean;
     get options(): CfgOption[];
     private _notifyAllOfChange;
@@ -148,6 +160,8 @@ export declare class CfgFeature {
     get preview(): string | undefined;
     get options(): CfgOption[];
     /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
      * Visibility is not inherited. If this is hidden the children
      * of this Feature might still be visible, depending on their settings.
      */

package/dist/productConfiguration/CfgFeature.js

@@ -86,9 +86,9 @@ export class _CfgFeatureInternal {
             if (bubbleMode === ProductConfigurationBubbleMode.Stop) {
                 return;
             }
-            const parent = this.parent;
             const freshRef = CfgFeature._makeNewRefFrom(this);
             this.changeObservable.notifyAll({ freshRef });
+            const parent = this.parent;
             if (parent !== undefined) {
                 yield parent._childHasChanged(freshRef, bubbleMode === ProductConfigurationBubbleMode.OneLevel
                     ? ProductConfigurationBubbleMode.Stop
@@ -450,12 +450,24 @@ export class _CfgFeatureInternal {
     get preview() {
         return getMtrlPreview(this._mtrlApplications);
     }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visibleIfAdditionalProduct() {
         return this.rawFeature.hideIfAdditionalProduct !== true;
     }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visibleIfMainProduct() {
         return this.rawFeature.hideIfMainProduct !== true;
     }
+    /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
+     */
     get visible() {
         return this.parentProduct.isAdditionalProduct
             ? this.visibleIfAdditionalProduct
@@ -588,6 +600,8 @@ export class CfgFeature {
         return this._internal.options;
     }
     /**
+     * Please note that this relates to the visibility in the Configuration tree.
+     * It does not affect the visibility of anything in the 3D view at all.
      * Visibility is not inherited. If this is hidden the children
      * of this Feature might still be visible, depending on their settings.
      */

package/dist/productConfiguration/CfgOption.js

@@ -233,7 +233,7 @@ export class _CfgOptionInternal {
             }
             else {
                 if (change) {
-                    yield this.parent._childHasChanged(this, ProductConfigurationBubbleMode.OneLevel);
+                    yield this.parent._childHasChanged(this, ProductConfigurationBubbleMode.Stop);
                 }
             }
             return change;

package/dist/productConfiguration/CfgProductConfiguration.d.ts

@@ -5,6 +5,7 @@ import { CfgFeature, _CfgFeatureInternal } from "./CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./CfgOption.js";
 export declare type ProductConfigurationChangeNotification = {
     freshRef: CfgProductConfiguration;
+    committed: boolean;
 };
 export declare type LengthValue = {
     length: number;
@@ -52,7 +53,7 @@ export declare class _CfgProductConfigurationInternal {
     /** Only selected features. */
     _getFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
     populateFeatures: (rootFeatureRefs: FeatureRef[]) => void;
-    setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit, doNotify?: boolean) => Promise<boolean>;
+    setStretchReferenceLength: (measureParamCode: string, referenceLength: number | undefined, unit: LengthUnit) => Promise<boolean>;
 }
 export declare class CfgProductConfiguration {
     readonly _internal: _CfgProductConfigurationInternal;

package/dist/productConfiguration/CfgProductConfiguration.js

@@ -27,7 +27,7 @@ export class _CfgProductConfigurationInternal {
         this._rootFeatureRefs = [];
         this._features = [];
         this.changeObservable = new Observable();
-        this._notifyAllOfChange = (bubbleMode) => __awaiter(this, void 0, void 0, function* () {
+        this._notifyAllOfChange = (bubbleMode, committed) => __awaiter(this, void 0, void 0, function* () {
             if (bubbleMode === ProductConfigurationBubbleMode.Stop) {
                 return;
             }
@@ -35,13 +35,14 @@ export class _CfgProductConfigurationInternal {
             const parent = this.parentProduct;
             this.changeObservable.notifyAll({
                 freshRef,
+                committed,
             });
             if (parent === undefined) {
                 return;
             }
             yield parent._configurationHasChanged(freshRef, bubbleMode === ProductConfigurationBubbleMode.OneLevel
                 ? ProductConfigurationBubbleMode.Stop
-                : bubbleMode);
+                : bubbleMode, committed);
         });
         /** Called by child to tell its parent that it has changed. */
         this._childHasChanged = (freshRef, bubbleMode) => __awaiter(this, void 0, void 0, function* () {
@@ -51,7 +52,7 @@ export class _CfgProductConfigurationInternal {
                 throw Error("Child feature not found");
             }
             features[i] = freshRef;
-            yield this._notifyAllOfChange(bubbleMode);
+            yield this._notifyAllOfChange(bubbleMode, true);
         });
         this.getApiSelection = () => this._features.map((f) => {
             return { code: "!~!", next: f._internal.getApiSelection() };
@@ -70,7 +71,7 @@ export class _CfgProductConfigurationInternal {
             if (change) {
                 yield this._notifyAllOfChange(bubbleToRoot
                     ? ProductConfigurationBubbleMode.ToRoot
-                    : ProductConfigurationBubbleMode.OneLevel);
+                    : ProductConfigurationBubbleMode.OneLevel, true);
             }
             return change;
         });
@@ -102,7 +103,7 @@ export class _CfgProductConfigurationInternal {
             if (change) {
                 yield this._notifyAllOfChange(validate
                     ? ProductConfigurationBubbleMode.Validate
-                    : ProductConfigurationBubbleMode.OneLevel);
+                    : ProductConfigurationBubbleMode.OneLevel, true);
             }
             return change;
         });
@@ -115,7 +116,7 @@ export class _CfgProductConfigurationInternal {
             this._rootFeatureRefs = rootFeatureRefs;
             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* () {
+        this.setStretchReferenceLength = (measureParamCode, referenceLength, unit) => __awaiter(this, void 0, void 0, function* () {
             if (measureParamCode === "") {
                 return false;
             }
@@ -146,9 +147,7 @@ export class _CfgProductConfigurationInternal {
                 }
                 stretchReferenceLength.current = referenceLengthWithUnit;
             }
-            if (doNotify) {
-                yield this._notifyAllOfChange(ProductConfigurationBubbleMode.ToRoot);
-            }
+            yield this._notifyAllOfChange(ProductConfigurationBubbleMode.ToRoot, false);
             return true;
         });
         // Useful debug tool:

package/dist/productLoader.d.ts

@@ -1,4 +1,4 @@
-import { GetProductParams, PostValidateParams, ValidateRequest } from "./CatalogueAPI";
+import { GetProductParams, PostValidateParams, ValidateRequest } from "./CatalogueAPI.js";
 import { CfgProductResponse, CfgValidateResponse } from "./utilitiesCatalogueData.js";
 export declare type GetProduct = (params: GetProductParams) => Promise<CfgProductResponse>;
 export declare type PostValidate = (params: PostValidateParams, body: ValidateRequest) => Promise<CfgValidateResponse>;

package/dist/tasks/TaskHandler.js

@@ -8,7 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Observable } from "@configura/web-utilities";
-import { allExportFormats, allRenderFormats, isExportFormat, isRenderFormat, } from "./formats.js";
+import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
+import { isExportFormat, isRenderFormat } from "./formats.js";
 const productToParams = (product) => (Object.assign(Object.assign({ lang: product.lang }, product.catId), { partNumber: product.partNumber }));
 export class _TaskHandlerInternal {
     constructor(api) {
@@ -55,10 +56,10 @@ export class _TaskHandlerInternal {
     get availableFormats() {
         const result = [];
         if (this.hasExport) {
-            result.push(...allExportFormats);
+            result.push(...exportFormatNames);
         }
         if (this.hasRender) {
-            result.push(...allRenderFormats);
+            result.push(...renderFormatNames);
         }
         return result;
     }

package/dist/tasks/formats.d.ts

@@ -1,6 +1,4 @@
-import { ExportFormat, RenderFormat } from "../CatalogueAPI";
-export declare const allRenderFormats: RenderFormat[];
-export declare const allExportFormats: ExportFormat[];
+import { ExportFormat, RenderFormat } from "../CatalogueAPI.js";
 export declare type RenderOrExportFormat = RenderFormat | ExportFormat;
 export declare function isRenderFormat(type: unknown): type is RenderFormat;
 export declare function isExportFormat(type: unknown): type is ExportFormat;

package/dist/tasks/formats.js

@@ -1,8 +1,7 @@
-export const allRenderFormats = ["jpg", "png"];
-export const allExportFormats = ["fbx", "dwg", "cmdrw", "cmfav", "cmsym"];
+import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
 export function isRenderFormat(type) {
-    return allRenderFormats.some((f) => type === f);
+    return renderFormatNames.some((f) => type === f);
 }
 export function isExportFormat(type) {
-    return allExportFormats.some((f) => type === f);
+    return exportFormatNames.some((f) => type === f);
 }

package/dist/tests/testData/dummyProductForTest.d.ts

@@ -1,5 +1,5 @@
-import { CatalogueParams } from "../../CatalogueAPI";
-import { CfgProduct } from "../../CfgProduct";
+import { CatalogueParams } from "../../CatalogueAPI.js";
+import { CfgProduct } from "../../CfgProduct.js";
 export declare const dummyCatId: CatalogueParams;
 export declare const getDummyCfgProduct: () => Promise<CfgProduct>;
 //# sourceMappingURL=dummyProductForTest.d.ts.map

package/dist/tests/testData/dummyProductForTest.js

@@ -1,4 +1,4 @@
-import { CfgProduct } from "../../CfgProduct";
+import { CfgProduct } from "../../CfgProduct.js";
 export const dummyCatId = {
     enterprise: "enterprise",
     prdCat: "prdCat",

package/dist/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.d.ts

@@ -1,6 +1,6 @@
-import { GetProductParams } from "../../CatalogueAPI";
-import { CfgProduct } from "../../CfgProduct";
-import { CfgProductResponse } from "../../utilitiesCatalogueData";
+import { GetProductParams } from "../../CatalogueAPI.js";
+import { CfgProduct } from "../../CfgProduct.js";
+import { CfgProductResponse } from "../../utilitiesCatalogueData.js";
 export declare const getTestProduct: (params: GetProductParams) => Promise<CfgProductResponse>;
 export declare const cfgProductTest: (testFunc: (product: CfgProduct) => Promise<void>, prepFunc?: ((product: CfgProduct) => Promise<void>) | undefined) => Promise<{
     beforeSnapshot: {

package/dist/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.js

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { CfgProduct } from "../../CfgProduct";
-import { Collector } from "./collectorForTest";
-import { dummyCatId } from "./dummyProductForTest";
+import { CfgProduct } from "../../CfgProduct.js";
+import { Collector } from "./collectorForTest.js";
+import { dummyCatId } from "./dummyProductForTest.js";
 const A = () => ({
     uuid: "A",
     unit: "m",

package/dist/tests/testData/testDataProductAggregatedPrice.d.ts

@@ -1,6 +1,6 @@
-import { GetProductParams, SelectedOption } from "../../CatalogueAPI";
-import { CfgProduct } from "../../CfgProduct";
-import { CfgProductResponse } from "../../utilitiesCatalogueData";
+import { GetProductParams, SelectedOption } from "../../CatalogueAPI.js";
+import { CfgProduct } from "../../CfgProduct.js";
+import { CfgProductResponse } from "../../utilitiesCatalogueData.js";
 export declare const getTestProduct: (params: GetProductParams) => Promise<CfgProductResponse>;
 export declare function getSelOptions(option: string): SelectedOption[];
 export declare const cfgProductPriceTest: (testFunc?: ((cfgProduct: CfgProduct) => Promise<void>) | undefined, featureOption?: string | undefined) => Promise<CfgProduct>;

package/dist/tests/testData/testDataProductAggregatedPrice.js

@@ -7,8 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { CfgProduct } from "../../CfgProduct";
-import { dummyCatId } from "./dummyProductForTest";
+import { CfgProduct } from "../../CfgProduct.js";
+import { dummyCatId } from "./dummyProductForTest.js";
 const A = () => ({
     uuid: "A",
     unit: "m",

package/dist/utilitiesCatalogueData.d.ts

@@ -1,4 +1,4 @@
-import { CatalogueParams, GetProductParams, Model, PartsData, Prices, ProductData, ProductResponse, SelectedOption, ValidateResponse } from "./CatalogueAPI";
+import { CatalogueParams, GetProductParams, Model, PartsData, Prices, ProductData, ProductResponse, SelectedOption, ValidateResponse } from "./CatalogueAPI.js";
 export declare const makeCatalogueKey: (cat: CatalogueParams) => string;
 export declare const makeProductKey: (cat: CatalogueParams, pKey: string) => string;
 export declare const makeSelOptionsKey: (options: SelectedOption[]) => string;

package/dist/utilitiesCatalogueData.js

@@ -2,14 +2,15 @@ import { shallowCompareDictionaries } from "@configura/web-utilities";
 export const makeCatalogueKey = (cat) => `${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
 export const makeProductKey = (cat, pKey) => `${makeCatalogueKey(cat)}-${pKey}`;
 export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
-    const { code, next } = option;
-    p += "_{" + code;
+    var _a;
+    const { code, numericValue, next } = option;
+    p += `_{${code}${numericValue === undefined ? "" : `_${numericValue.value}${(_a = numericValue.unit) !== null && _a !== void 0 ? _a : ""}`}`;
     if (next === undefined) {
         return p;
     }
     for (const key of Object.keys(next)) {
         const innerOption = next[key];
-        p += "_{" + key + "_" + makeSelOptionsKey([innerOption]) + "_}";
+        p += `_{${key}_${makeSelOptionsKey([innerOption])}_}`;
     }
     p += "_}";
     return p;

package/dist/utilitiesNumericValues.d.ts

@@ -1,4 +1,4 @@
-import { CodeRange } from "./CatalogueAPI";
+import { CodeRange } from "./CatalogueAPI.js";
 export declare class NumericValuesSelection {
     constructor(rawRanges: CodeRange[]);
     readonly ranges: (NumericValueRangeDefinition | NumericValueDiscrete)[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/web-api",
-	"version": "1.5.0-alpha.0",
+	"version": "1.6.0-iotest.0",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "^1.5.0-alpha.0"
+		"@configura/web-utilities": "1.6.0-iotest.0"
 	},
-	"gitHead": "6e24920b36ac225b17fcb519c0f4b7c6af924fbd"
+	"gitHead": "afcb290fa6c4a3f87ab1b4ac781bd704acaa0ad9"
 }