@configura/web-api 1.5.0-alpha.0 → 1.6.1-alpha.0

package/dist/syncGroups/SyncGroupsState.js

@@ -0,0 +1,61 @@
+/**
+ * Is used to keep track of the current value of the SyncGroups. Is fully separated between
+ * SelectOne and SelectMany as Features of the two types are synced separately.
+ */
+export class SyncGroupsState {
+    constructor() {
+        this._selectOne = new Map();
+        this._selectMany = new Map();
+    }
+    clone() {
+        const result = new SyncGroupsState();
+        result.setFrom(this);
+        return result;
+    }
+    /**
+     * Replaces the current state
+     */
+    setFrom(other) {
+        this._selectOne.clear();
+        this._selectMany.clear();
+        for (const [k, v] of other._selectOne) {
+            this._selectOne.set(k, v);
+        }
+        for (const [sourceSyncCode, sourceOptionToSelected] of other._selectMany) {
+            const targetOptionToSelected = new Map();
+            for (const [sourceOptionCode, sourceIsSelected] of sourceOptionToSelected) {
+                targetOptionToSelected.set(sourceOptionCode, sourceIsSelected);
+            }
+            this._selectMany.set(sourceSyncCode, targetOptionToSelected);
+        }
+    }
+    setForSelectOne(syncCode, optionCode) {
+        this._selectOne.set(syncCode, optionCode);
+        this.logDebug();
+    }
+    setForSelectMany(syncCode, optionCode, selected) {
+        let forSyncCode = this._selectMany.get(syncCode);
+        if (forSyncCode === undefined) {
+            forSyncCode = new Map();
+            this._selectMany.set(syncCode, forSyncCode);
+        }
+        forSyncCode.set(optionCode, selected);
+        this.logDebug();
+    }
+    getForSelectOne(syncCode) {
+        return this._selectOne.get(syncCode);
+    }
+    getForSelectMany(syncCode, optionCode) {
+        var _a;
+        return (_a = this._selectMany.get(syncCode)) === null || _a === void 0 ? void 0 : _a.get(optionCode);
+    }
+    logDebug() {
+        console.table(Array.from(this._selectOne.entries()));
+        console.table(Array.from(this._selectMany.entries()).reduce((a, [groupCode, optionCodeToSelected]) => {
+            for (const [optionCode, selected] of optionCodeToSelected) {
+                a.push([groupCode, optionCode, selected]);
+            }
+            return a;
+        }, []));
+    }
+}

package/dist/syncGroups/SyncGroupsTransaction.d.ts

@@ -0,0 +1,50 @@
+import { CfgPath, _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgFeatureInternal } from "../productConfiguration/CfgFeature.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { ProductLoader } from "../productLoader.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { OptionCode, SyncCode } from "./SyncGroupsHandler.js";
+import { SyncGroupsState } from "./SyncGroupsState.js";
+/**
+ * A transaction is normally limited to one user interaction. Like opening a product or
+ * selecting an option. This object is used to keep data for one transaction. In particular
+ * what Features and what SyncGroups have been affected in the transaction. This is a means
+ * to eliminate the risk of infinite loops.
+ */
+export declare class SyncGroupsTransaction {
+    readonly syncState: SyncGroupsState;
+    readonly updateMode: SyncGroupsApplyMode;
+    readonly productLoader: ProductLoader;
+    readonly original: _CfgProductInternal;
+    readonly target: _CfgProductInternal;
+    readonly initial: _CfgProductInternal | undefined;
+    static make(syncState: SyncGroupsState, updateMode: SyncGroupsApplyMode, product: _CfgProductInternal, productLoader: ProductLoader, assumeNoStartState: boolean): Promise<SyncGroupsTransaction>;
+    /**
+     *
+     * @param syncState A clone of the original syncState. Replaces the original syncState if nothing fails and the transaction doesn't get aborted
+     * @param updateMode
+     * @param productLoader
+     * @param original The product instance that this transaction will be applied on provided nothing fails and the transaction doesn't get aborted
+     * @param target A clone of the original product used to apply the configuration changes to
+     * @param initial A clone of the original product used to track what the original state was. As a safe measure we do not use originalProduct for this, as it might be changed by someone else
+     */
+    private constructor();
+    private _aborted;
+    private affectedSelectOneFeatures;
+    private affectedSelectManyOptions;
+    private affectedSelectOneSyncGroups;
+    private affectedSelectManySyncGroupsAndOptions;
+    get isAborted(): boolean;
+    abort(): void;
+    init(): Promise<boolean>;
+    selectOption(optionPath: CfgPath, on: boolean): Promise<boolean>;
+    addSelectOneFeatureAffected(feature: _CfgFeatureInternal): void;
+    addSelectManyOptionAffected(option: _CfgOptionInternal): void;
+    hasSelectOneFeatureBeenAffected(feature: _CfgFeatureInternal): boolean;
+    hasSelectManyOptionBeenAffected(option: _CfgOptionInternal): boolean;
+    addSyncGroupAffectedForSelectOne(syncCode: SyncCode): void;
+    addSyncGroupAffectedForSelectMany(syncCode: SyncCode, optionCode: OptionCode): void;
+    isSyncGroupAffectedForSelectOne(syncCode: SyncCode): boolean;
+    isSyncGroupAffectedForSelectMany(syncCode: SyncCode, optionCode: OptionCode): boolean;
+}
+//# sourceMappingURL=SyncGroupsTransaction.d.ts.map

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -0,0 +1,106 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SelectionType } from "../productConfiguration/CfgFeature.js";
+import { SyncGroupsApplier } from "./SyncGroupsApplier.js";
+/**
+ * A transaction is normally limited to one user interaction. Like opening a product or
+ * selecting an option. This object is used to keep data for one transaction. In particular
+ * what Features and what SyncGroups have been affected in the transaction. This is a means
+ * to eliminate the risk of infinite loops.
+ */
+export class SyncGroupsTransaction {
+    /**
+     *
+     * @param syncState A clone of the original syncState. Replaces the original syncState if nothing fails and the transaction doesn't get aborted
+     * @param updateMode
+     * @param productLoader
+     * @param original The product instance that this transaction will be applied on provided nothing fails and the transaction doesn't get aborted
+     * @param target A clone of the original product used to apply the configuration changes to
+     * @param initial A clone of the original product used to track what the original state was. As a safe measure we do not use originalProduct for this, as it might be changed by someone else
+     */
+    constructor(syncState, updateMode, productLoader, original, target, initial) {
+        this.syncState = syncState;
+        this.updateMode = updateMode;
+        this.productLoader = productLoader;
+        this.original = original;
+        this.target = target;
+        this.initial = initial;
+        this._aborted = false;
+        this.affectedSelectOneFeatures = new Set();
+        this.affectedSelectManyOptions = new Set();
+        this.affectedSelectOneSyncGroups = new Set();
+        this.affectedSelectManySyncGroupsAndOptions = new Map();
+    }
+    static make(syncState, updateMode, product, productLoader, assumeNoStartState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const t = new this(syncState.clone(), updateMode, productLoader, product, yield product.clone(), assumeNoStartState ? undefined : yield product.clone());
+            return t;
+        });
+    }
+    get isAborted() {
+        return this._aborted;
+    }
+    abort() {
+        this._aborted = true;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield SyncGroupsApplier.init(this);
+        });
+    }
+    selectOption(optionPath, on) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetOption = this.target.getOptionFromPath(optionPath);
+            return yield SyncGroupsApplier.selectOption(this, targetOption, on);
+        });
+    }
+    addSelectOneFeatureAffected(feature) {
+        if (feature.selectionType !== SelectionType.SelectOne) {
+            throw new Error("Can only be used for SelectOne Feature");
+        }
+        this.affectedSelectOneFeatures.add(feature);
+    }
+    addSelectManyOptionAffected(option) {
+        if (option.parent.selectionType !== SelectionType.SelectMany) {
+            throw new Error("Can only be used for option in SelectMany Feature");
+        }
+        this.affectedSelectManyOptions.add(option);
+    }
+    hasSelectOneFeatureBeenAffected(feature) {
+        if (feature.selectionType !== SelectionType.SelectOne) {
+            throw new Error("Can only be used for SelectOne Feature");
+        }
+        return this.affectedSelectOneFeatures.has(feature);
+    }
+    hasSelectManyOptionBeenAffected(option) {
+        if (option.parent.selectionType !== SelectionType.SelectMany) {
+            throw new Error("Can only be used for option in SelectMany Feature");
+        }
+        return this.affectedSelectManyOptions.has(option);
+    }
+    addSyncGroupAffectedForSelectOne(syncCode) {
+        this.affectedSelectOneSyncGroups.add(syncCode);
+    }
+    addSyncGroupAffectedForSelectMany(syncCode, optionCode) {
+        let forSyncCode = this.affectedSelectManySyncGroupsAndOptions.get(syncCode);
+        if (forSyncCode === undefined) {
+            forSyncCode = new Set();
+            this.affectedSelectManySyncGroupsAndOptions.set(syncCode, forSyncCode);
+        }
+        forSyncCode.add(optionCode);
+    }
+    isSyncGroupAffectedForSelectOne(syncCode) {
+        return this.affectedSelectOneSyncGroups.has(syncCode);
+    }
+    isSyncGroupAffectedForSelectMany(syncCode, optionCode) {
+        var _a;
+        return ((_a = this.affectedSelectManySyncGroupsAndOptions.get(syncCode)) === null || _a === void 0 ? void 0 : _a.has(optionCode)) === true;
+    }
+}

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,10 @@ 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";
+import { letterOptionCodeA, letterOptionCodeB, letterOptionCodeC, letterOptions, } from "./testDataOptions.js";
 const A = () => ({
     uuid: "A",
     unit: "m",
@@ -19,96 +20,37 @@ const A = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "optionA",
-                    description: "",
-                    additionalProductRefs: [
+                Object.assign(Object.assign({}, letterOptions[0]), { additionalProductRefs: [
                         { refKey: "C_0", catId: dummyCatId, partNumber: "C" },
                         { refKey: "B_0", catId: dummyCatId, partNumber: "B" },
-                    ],
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                    additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }],
-                },
+                    ] }),
+                letterOptions[1],
+                Object.assign(Object.assign({}, letterOptions[2]), { additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }] }),
             ],
         },
         {
             code: "featureX",
             description: "",
             numericOrder: false,
-            options: [
-                {
-                    code: "optionA",
-                    description: "",
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                },
-            ],
+            options: [...letterOptions],
         },
         {
             code: "featureNotUsed",
             description: "",
             numericOrder: false,
-            options: [
-                {
-                    code: "optionA",
-                    description: "",
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-            ],
+            options: [...letterOptions],
         },
         {
             code: "featureOptionCSelectedAtStart",
             description: "",
             numericOrder: false,
-            options: [
-                {
-                    code: "optionA",
-                    description: "",
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                },
-            ],
+            options: [...letterOptions],
         },
         {
             code: "featureSelectMany",
             description: "",
             numericOrder: false,
-            options: [
-                {
-                    code: "optionA",
-                    description: "",
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                },
-            ],
+            options: [...letterOptions],
         },
     ],
     productData: {
@@ -123,24 +65,24 @@ const A = () => ({
                 {
                     code: "!~!",
                     next: {
-                        optionA: {
-                            code: "optionA",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        optionB: {
-                            code: "optionB",
+                        [letterOptionCodeB]: {
+                            code: letterOptionCodeB,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        optionC: {
-                            code: "optionC",
+                        [letterOptionCodeC]: {
+                            code: letterOptionCodeC,
                         },
                     },
                 },
@@ -219,20 +161,7 @@ const C = () => ({
             code: "featureC",
             description: "",
             numericOrder: false,
-            options: [
-                {
-                    code: "optionA",
-                    description: "",
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                },
-            ],
+            options: [...letterOptions],
         },
     ],
     productData: {
@@ -246,8 +175,8 @@ const C = () => ({
                 {
                     code: "!~!",
                     next: {
-                        optionA: {
-                            code: "optionA",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
@@ -297,8 +226,8 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
                 {
                     code: "!~!",
                     next: {
-                        optionC: {
-                            code: "optionC",
+                        [letterOptionCodeC]: {
+                            code: letterOptionCodeC,
                         },
                     },
                 },
@@ -307,16 +236,16 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
                 productData.partsData.selOptions.push({
                     code: "!~!",
                     next: {
-                        optionC: {
-                            code: "optionC",
+                        [letterOptionCodeC]: {
+                            code: letterOptionCodeC,
                         },
                     },
                 });
                 productData.partsData.selOptions.push({
                     code: "!~!",
                     next: {
-                        optionC: {
-                            code: "optionC",
+                        [letterOptionCodeC]: {
+                            code: letterOptionCodeC,
                         },
                     },
                 });

package/dist/tests/testData/testDataCachedGetProduct.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { CfgProduct } from "../../CfgProduct.js";
 import { wrapWithGetProductCache } from "../../productLoader.js";
 import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptions } from "./testDataOptions.js";
 let prodKeyArray = [];
 const A = () => ({
     uuid: "A",
@@ -20,24 +21,12 @@ const A = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "optionA",
-                    description: "",
-                    additionalProductRefs: [
+                Object.assign(Object.assign({}, letterOptions[0]), { additionalProductRefs: [
                         { refKey: "C_0", catId: dummyCatId, partNumber: "C" },
                         { refKey: "B_0", catId: dummyCatId, partNumber: "B" },
-                    ],
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                    additionalProductRefs: [{ refKey: "E", catId: dummyCatId, partNumber: "E" }],
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                    additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }],
-                },
+                    ] }),
+                Object.assign(Object.assign({}, letterOptions[1]), { additionalProductRefs: [{ refKey: "E", catId: dummyCatId, partNumber: "E" }] }),
+                Object.assign(Object.assign({}, letterOptions[2]), { additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }] }),
             ],
         },
     ],
@@ -53,8 +42,8 @@ const A = () => ({
                 {
                     code: "!~!",
                     next: {
-                        optionA: {
-                            code: "optionA",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
@@ -165,7 +154,7 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
         getProduct: getTestProduct,
         postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
             const productData = (yield getTestProduct(params, true)).productData;
-            let code = "optionA";
+            let code = letterOptionCodeA;
             for (let test in _body.selOptions[0].next) {
                 code = test;
                 break;

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

@@ -0,0 +1,13 @@
+import { Option, SelectedOption } from "../../CatalogueAPI.js";
+export declare function addDefaultsToMockSelectedOption(root: SelectedOption, optionCodeToAdd: string | undefined, optionCodesToRemove: string[], unlessOptionCodes: string[]): void;
+export declare const letterOptionCodeA = "optA";
+export declare const letterOptionCodeB = "optB";
+export declare const letterOptionCodeC = "optC";
+export declare const letterOptionCodeD = "optD";
+export declare const letterOptionCodeE = "optE";
+export declare const letterOptionCodeF = "optF";
+export declare const letterOptions: Option[];
+export declare const toggleOptionCodeOff = "optOff";
+export declare const toggleOptionCodeOn = "optOn";
+export declare const toggleOptions: Option[];
+//# sourceMappingURL=testDataOptions.d.ts.map

package/dist/tests/testData/testDataOptions.js

@@ -0,0 +1,60 @@
+export function addDefaultsToMockSelectedOption(root, optionCodeToAdd, optionCodesToRemove, unlessOptionCodes) {
+    let next = root.next;
+    if (next === undefined) {
+        if (optionCodeToAdd === undefined) {
+            return;
+        }
+        next = {};
+        root.next = next;
+    }
+    for (const oCode of unlessOptionCodes) {
+        if (next[oCode] !== undefined) {
+            return;
+        }
+    }
+    for (const oCode of optionCodesToRemove) {
+        delete next[oCode];
+    }
+    if (optionCodeToAdd === undefined) {
+        return;
+    }
+    next[optionCodeToAdd] = { code: optionCodeToAdd };
+}
+export const letterOptionCodeA = "optA";
+export const letterOptionCodeB = "optB";
+export const letterOptionCodeC = "optC";
+export const letterOptionCodeD = "optD";
+export const letterOptionCodeE = "optE";
+export const letterOptionCodeF = "optF";
+export const letterOptions = [
+    {
+        code: letterOptionCodeA,
+        description: "",
+    },
+    {
+        code: letterOptionCodeB,
+        description: "",
+    },
+    {
+        code: letterOptionCodeC,
+        description: "",
+    },
+    {
+        code: letterOptionCodeD,
+        description: "",
+    },
+    {
+        code: letterOptionCodeE,
+        description: "",
+    },
+    {
+        code: letterOptionCodeF,
+        description: "",
+    },
+];
+export const toggleOptionCodeOff = "optOff";
+export const toggleOptionCodeOn = "optOn";
+export const toggleOptions = [
+    { code: toggleOptionCodeOff, description: "" },
+    { code: toggleOptionCodeOn, description: "" },
+];

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>;