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

package/dist/syncGroups/SyncGroupsPathHelper.d.ts

@@ -0,0 +1,27 @@
+import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgFeatureInternal } from "../productConfiguration/CfgFeature.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { _CfgProductConfigurationInternal } from "../productConfiguration/CfgProductConfiguration.js";
+export declare type CfgPathSegment = string;
+/**
+ * Represents the path to a node in the configuration tree.
+ *
+ * The format consists of a number of CfgPathSegments, each of which is currently a string. The
+ * exact meaning of the strings vary depending on where they are located in the path.
+ *
+ * @warning
+ * The format is strictly internal and can change in later versions of the SDK.
+ * Data stored in a CfgPath should be thus be considered transient and never stored or transmitted.
+ */
+export declare type CfgPath = CfgPathSegment[];
+declare type PathItemType = _CfgProductInternal | _CfgProductConfigurationInternal | _CfgFeatureInternal | _CfgOptionInternal;
+export declare class SyncGroupsPathHelper {
+    static getPath(item: PathItemType): CfgPath;
+    static getFromPath(path: CfgPath, root: PathItemType): PathItemType;
+    static getProductFromPath(path: CfgPath, item: _CfgProductInternal): _CfgProductInternal;
+    static getProductConfigurationFromPath(path: CfgPath, item: _CfgProductInternal): _CfgProductConfigurationInternal;
+    static getFeatureFromPath(path: CfgPath, item: PathItemType): _CfgFeatureInternal;
+    static getOptionFromPath(path: CfgPath, item: PathItemType): _CfgOptionInternal;
+}
+export {};
+//# sourceMappingURL=SyncGroupsPathHelper.d.ts.map

package/dist/syncGroups/SyncGroupsPathHelper.js

@@ -0,0 +1,89 @@
+import { assert, assertDefined } from "@configura/web-utilities";
+import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgFeatureInternal } from "../productConfiguration/CfgFeature.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { _CfgProductConfigurationInternal } from "../productConfiguration/CfgProductConfiguration.js";
+export class SyncGroupsPathHelper {
+    static getPath(item) {
+        if (item instanceof _CfgProductInternal) {
+            const parent = item.parent;
+            const refKey = item.refKey;
+            if (parent === undefined || refKey === undefined) {
+                return [];
+            }
+            return [...this.getPath(parent), "p", refKey];
+        }
+        if (item instanceof _CfgProductConfigurationInternal) {
+            return [...this.getPath(item.parentProduct), "c"];
+        }
+        if (item instanceof _CfgFeatureInternal) {
+            return [...this.getPath(item.parent), item.code];
+        }
+        if (item instanceof _CfgOptionInternal) {
+            return [...this.getPath(item.parent), item.code];
+        }
+        throw new Error("This should not happen");
+    }
+    static getFromPath(path, root) {
+        path = path.slice();
+        let item = root;
+        while (path.length > 0) {
+            const segment = path.shift();
+            if (item instanceof _CfgProductInternal) {
+                switch (segment) {
+                    case "p":
+                        const refKey = path.shift();
+                        const additional = item.additionalProducts.find((p) => p.refKey === refKey);
+                        assertDefined(additional, `Additional product not found "p, ${refKey}, ${path.join(", ")}"`);
+                        item = additional._internal;
+                        break;
+                    case "c":
+                        assert(item instanceof _CfgProductInternal, "Was not product");
+                        item = item.configuration._internal;
+                        break;
+                    default:
+                        throw new Error(`Unexpected path segment ${segment}`);
+                }
+            }
+            else if (item instanceof _CfgProductConfigurationInternal) {
+                const feature = item.features.find((f) => f.code === segment);
+                assertDefined(feature, `Feature not found ${segment}, ${path.join(", ")}`);
+                item = feature._internal;
+            }
+            else if (item instanceof _CfgFeatureInternal) {
+                const option = item.options.find((o) => o.code === segment);
+                assertDefined(option, `Option not found ${segment}, ${path.join(", ")}`);
+                item = option._internal;
+            }
+            else if (item instanceof _CfgOptionInternal) {
+                const feature = item.features.find((o) => o.code === segment);
+                assertDefined(feature, `Feature not found ${segment}, ${path.join(", ")}`);
+                item = feature._internal;
+            }
+            else {
+                throw new Error("This should not happen (unexpected type)");
+            }
+        }
+        return item;
+    }
+    static getProductFromPath(path, item) {
+        const p = this.getFromPath(path, item);
+        assert(p instanceof _CfgProductInternal, `Path did not lead to a Product`);
+        return p;
+    }
+    static getProductConfigurationFromPath(path, item) {
+        const c = this.getFromPath(path, item);
+        assert(c instanceof _CfgProductConfigurationInternal, `Path did not lead to a ProductConfiguration"`);
+        return c;
+    }
+    static getFeatureFromPath(path, item) {
+        const f = this.getFromPath(path, item);
+        assert(f instanceof _CfgFeatureInternal, `Path did not lead to a Feature`);
+        return f;
+    }
+    static getOptionFromPath(path, item) {
+        const o = this.getFromPath(path, item);
+        assert(o instanceof _CfgOptionInternal, `Path did not lead to a Option`);
+        return o;
+    }
+}

package/dist/syncGroups/SyncGroupsState.d.ts

@@ -0,0 +1,20 @@
+import { OptionCode, SyncCode } from "./SyncGroupsHandler.js";
+/**
+ * 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 declare class SyncGroupsState {
+    readonly _selectOne: Map<SyncCode, OptionCode>;
+    readonly _selectMany: Map<SyncCode, Map<OptionCode, boolean>>;
+    clone(): SyncGroupsState;
+    /**
+     * Replaces the current state
+     */
+    setFrom(other: SyncGroupsState): void;
+    setForSelectOne(syncCode: SyncCode, optionCode: OptionCode): void;
+    setForSelectMany(syncCode: SyncCode, optionCode: OptionCode, selected: boolean): void;
+    getForSelectOne(syncCode: SyncCode): OptionCode | undefined;
+    getForSelectMany(syncCode: SyncCode, optionCode: OptionCode): boolean | undefined;
+    logDebug(group?: string, code?: string, selected?: boolean): void;
+}
+//# sourceMappingURL=SyncGroupsState.d.ts.map

package/dist/syncGroups/SyncGroupsState.js

@@ -0,0 +1,108 @@
+/**
+ * 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(syncCode, optionCode);
+    }
+    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(syncCode, optionCode, selected);
+    }
+    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(group, code, selected) {
+        const isMany = selected !== undefined;
+        const selectOne = Array.from(this._selectOne.entries());
+        const selectMany = Array.from(this._selectMany.entries()).reduce((a, [groupCode, optionCodeToSelected]) => {
+            for (const [optionCode, selected] of optionCodeToSelected) {
+                a.push([groupCode, optionCode, selected]);
+            }
+            return a;
+        }, []);
+        let columnWidth = 1;
+        selectOne.forEach((e) => {
+            columnWidth = Math.max(columnWidth, e[0].length);
+        });
+        selectMany.forEach((e) => {
+            columnWidth = Math.max(columnWidth, e[0].length);
+        });
+        const padding = Array(columnWidth).join(" ");
+        const styleBold = "font-weight: bold";
+        const styleBoldThis = "color:blue; font-weight: bold";
+        const styleBoldOn = "color:green; font-weight: bold";
+        const styleBoldOff = "color:red; font-weight: bold";
+        const styleThis = "color:blue";
+        const styleOn = "color:green";
+        const styleOff = "color:red";
+        const output = [];
+        if (group === undefined) {
+            output.push("");
+        }
+        else if (isMany) {
+            output.push(...[
+                `%c${code} %cin %c${group} %cset to %c${selected ? "on" : "off"}\n`,
+                styleBoldThis,
+                "",
+                styleBoldThis,
+                "",
+                selected ? styleBoldOn : styleBoldOff,
+            ]);
+        }
+        else {
+            output.push(...[`%c${group}%c set to %c${code}\n`, styleBoldThis, "", styleBoldThis]);
+        }
+        output[0] = output[0] + "%cSync State (single)";
+        output.push(styleBold);
+        selectOne.forEach((e) => {
+            output[0] = output[0] + `\n  %c${(padding + e[0]).slice(-columnWidth)}: ${e[1]}`;
+            output.push(!isMany && group === e[0] ? styleThis : "");
+        });
+        output[0] = output[0] + "\n%cSync State (multi)";
+        output.push(styleBold);
+        selectMany.forEach((e) => {
+            output[0] = output[0] + `\n  %c${(padding + e[0]).slice(-columnWidth)}: %c${e[1]}`;
+            output.push(isMany && group === e[0] ? styleThis : "");
+            output.push(e[2] === true ? styleOn : styleOff);
+        });
+        console.log(...output);
+    }
+}

package/dist/syncGroups/SyncGroupsTransaction.d.ts

@@ -0,0 +1,51 @@
+import { _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 { CfgPath } from "./SyncGroupsPathHelper.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,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 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 = 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;