@configura/web-api 1.6.0-iotest.4 → 1.6.1-alpha.2

package/dist/syncGroups/SyncGroupsTransaction.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());
+    });
+};
+import { assert } from "@configura/web-utilities";
+import { SelectionType } from "../productConfiguration/CfgFeature.js";
+import { SyncGroupsApplier } from "./SyncGroupsApplier.js";
+import { SyncGroupsPathHelper } from "./SyncGroupsPathHelper.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 cancelled
+     * @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 cancelled
+     * @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._closed = 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 isClosed() {
+        return this._closed;
+    }
+    close() {
+        this._closed = 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 = SyncGroupsPathHelper.getOptionFromPath(optionPath, this.target);
+            return yield SyncGroupsApplier.selectOption(this, targetOption, on);
+        });
+    }
+    addSelectOneFeatureAffected(feature) {
+        assert(feature.selectionType === SelectionType.SelectOne, "Can only be used for SelectOne Feature");
+        this.affectedSelectOneFeatures.add(feature);
+    }
+    addSelectManyOptionAffected(option) {
+        assert(option.parent.selectionType === SelectionType.SelectMany, "Can only be used for option in SelectMany Feature");
+        this.affectedSelectManyOptions.add(option);
+    }
+    hasSelectOneFeatureBeenAffected(feature) {
+        assert(feature.selectionType === SelectionType.SelectOne, "Can only be used for SelectOne Feature");
+        return this.affectedSelectOneFeatures.has(feature);
+    }
+    hasSelectManyOptionBeenAffected(option) {
+        assert(option.parent.selectionType === SelectionType.SelectMany, "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/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 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.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { CfgProduct } from "../../CfgProduct.js";
 import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptionCodeB, letterOptionCodeC, letterOptions, } from "./testDataOptions.js";
 const A = () => ({
     uuid: "A",
     unit: "m",
@@ -18,24 +19,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" }] }),
             ],
         },
     ],
@@ -51,8 +40,8 @@ const A = () => ({
                 {
                     code: "!~!",
                     next: {
-                        optionA: {
-                            code: "optionA",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
@@ -150,13 +139,13 @@ export const getTestProduct = (params) => __awaiter(void 0, void 0, void 0, func
     throw new Error("No such part");
 });
 export function getSelOptions(option) {
-    if (option === "optionB") {
+    if (option === letterOptionCodeB) {
         return [
             {
                 code: "!~!",
                 next: {
-                    optionB: {
-                        code: "optionB",
+                    [letterOptionCodeB]: {
+                        code: letterOptionCodeB,
                     },
                 },
             },
@@ -167,8 +156,8 @@ export function getSelOptions(option) {
             {
                 code: "!~!",
                 next: {
-                    optionC: {
-                        code: "optionC",
+                    [letterOptionCodeC]: {
+                        code: letterOptionCodeC,
                     },
                 },
             },

package/dist/tests/testData/testDataUpcharge.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { CfgProduct } from "../../CfgProduct.js";
 import { Collector } from "./collectorForTest.js";
 import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptions } from "./testDataOptions.js";
 const Prd = () => ({
     uuid: "Prd",
     unit: "m",
@@ -19,20 +20,9 @@ const Prd = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 0,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 0 }),
             ],
         },
         {
@@ -40,20 +30,9 @@ const Prd = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
             ],
         },
         {
@@ -62,20 +41,9 @@ const Prd = () => ({
             numericOrder: false,
             optional: true,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
             ],
         },
     ],
@@ -91,24 +59,24 @@ const Prd = () => ({
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },

package/dist/utilitiesCatalogueData.d.ts

@@ -1,4 +1,4 @@
-import { CatalogueParams, GetProductParams, Model, PartsData, Prices, ProductData, ProductResponse, SelectedOption, ValidateResponse } from "./CatalogueAPI.js";
+import { AdditionalProductRef, CatalogueParams, GetProductParams, MeasureParam, Model, Orientation, PartsData, Prices, ProductData, ProductResponse, SelectedOption, Transform, ValidateResponse, Vector } 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;
@@ -23,4 +23,10 @@ export declare function recursivelyGetPriceCodeValue(priceCodes: string[], price
 export declare function comparePricesObjects(prices1: Prices | undefined, prices2: Prices | undefined): boolean;
 export declare const decodeCatalogueParams: <T extends CatalogueParams>(params: T) => T;
 export declare const decodeProductParams: <T extends GetProductParams>(params: T) => T;
+export declare function isSameCatalogueParams(left: CatalogueParams, right: CatalogueParams): boolean;
+export declare function isSameVector(left: Vector, right: Vector): boolean;
+export declare function isSameOrientation(left: Orientation, right: Orientation): boolean;
+export declare function isSameAnchor(left: MeasureParam, right: MeasureParam): boolean;
+export declare function isSameTransform(left: Transform, right: Transform): boolean;
+export declare function isSameProductRef(left: AdditionalProductRef, right: AdditionalProductRef): boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map