@configura/web-api 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/tests/testData/testDataUpcharge.js

@@ -1,119 +1,119 @@
-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 { 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",
-    features: [
-        {
-            code: "NoUpcharge",
-            description: "",
-            numericOrder: false,
-            options: [
-                letterOptions[0],
-                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
-                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 0 }),
-            ],
-        },
-        {
-            code: "WithUpcharge",
-            description: "",
-            numericOrder: false,
-            options: [
-                letterOptions[0],
-                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
-                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
-            ],
-        },
-        {
-            code: "WithUpchargeSelectMany",
-            description: "",
-            numericOrder: false,
-            optional: true,
-            options: [
-                letterOptions[0],
-                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
-                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
-            ],
-        },
-    ],
-    productData: {
-        sku: "Prd",
-        partsData: {
-            basePrice: 40,
-            currency: "EURO",
-            listPrice: 50,
-            pkgCount: 0,
-            styleNr: "",
-            selOptions: [
-                {
-                    code: "!~!",
-                    next: {
-                        [letterOptionCodeA]: {
-                            code: letterOptionCodeA,
-                        },
-                    },
-                },
-                {
-                    code: "!~!",
-                    next: {
-                        [letterOptionCodeA]: {
-                            code: letterOptionCodeA,
-                        },
-                    },
-                },
-                {
-                    code: "!~!",
-                    next: {
-                        [letterOptionCodeA]: {
-                            code: letterOptionCodeA,
-                        },
-                    },
-                },
-            ],
-        },
-    },
-    rootFeatureRefs: [
-        { code: "NoUpcharge" },
-        { code: "WithUpcharge" },
-        { code: "WithUpchargeSelectMany" },
-    ],
-});
-const getProduct = (params) => Promise.resolve(Prd());
-export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0, function* () {
-    const productLoader = {
-        getProduct,
-        postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
-            const productData = (yield getProduct(params)).productData;
-            const validateResponse = {
-                uuid: "",
-                validated: true,
-                productData,
-            };
-            return validateResponse;
-        }),
-    };
-    const product = yield CfgProduct.make(productLoader, Object.assign(Object.assign({}, dummyCatId), { partNumber: "Table" }));
-    const collect = new Collector(product);
-    const beforeSnapshot = collect.takeSnapshot();
-    yield testFunc(product);
-    const afterSnapshot = collect.takeSnapshot();
-    const diff = collect.compareSnapshot(beforeSnapshot, afterSnapshot);
-    const notifications = collect.notifications;
-    return {
-        beforeSnapshot: Collector.stripRefsForWrapper(beforeSnapshot),
-        afterSnapshot: Collector.stripRefsForWrapper(afterSnapshot),
-        diff,
-        notifications,
-    };
-});
+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 { 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",
+    features: [
+        {
+            code: "NoUpcharge",
+            description: "",
+            numericOrder: false,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 0 }),
+            ],
+        },
+        {
+            code: "WithUpcharge",
+            description: "",
+            numericOrder: false,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
+            ],
+        },
+        {
+            code: "WithUpchargeSelectMany",
+            description: "",
+            numericOrder: false,
+            optional: true,
+            options: [
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
+            ],
+        },
+    ],
+    productData: {
+        sku: "Prd",
+        partsData: {
+            basePrice: 40,
+            currency: "EURO",
+            listPrice: 50,
+            pkgCount: 0,
+            styleNr: "",
+            selOptions: [
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+                {
+                    code: "!~!",
+                    next: {
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
+                        },
+                    },
+                },
+            ],
+        },
+    },
+    rootFeatureRefs: [
+        { code: "NoUpcharge" },
+        { code: "WithUpcharge" },
+        { code: "WithUpchargeSelectMany" },
+    ],
+});
+const getProduct = (params) => Promise.resolve(Prd());
+export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0, function* () {
+    const productLoader = {
+        getProduct,
+        postValidate: (params, _body) => __awaiter(void 0, void 0, void 0, function* () {
+            const productData = (yield getProduct(params)).productData;
+            const validateResponse = {
+                uuid: "",
+                validated: true,
+                productData,
+            };
+            return validateResponse;
+        }),
+    };
+    const product = yield CfgProduct.make(productLoader, Object.assign(Object.assign({}, dummyCatId), { partNumber: "Table" }));
+    const collect = new Collector(product);
+    const beforeSnapshot = collect.takeSnapshot();
+    yield testFunc(product);
+    const afterSnapshot = collect.takeSnapshot();
+    const diff = collect.compareSnapshot(beforeSnapshot, afterSnapshot);
+    const notifications = collect.notifications;
+    return {
+        beforeSnapshot: Collector.stripRefsForWrapper(beforeSnapshot),
+        afterSnapshot: Collector.stripRefsForWrapper(afterSnapshot),
+        diff,
+        notifications,
+    };
+});

package/dist/utilitiesCatalogueData.d.ts

@@ -1,34 +1,34 @@
-import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithLang, DtoCatalogueParamsWithoutCid, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParams, DtoProductParamsWithLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
-export declare const makeCatalogueKey: (cat: DtoCatalogueParams) => string;
-export declare const makeProductKey: (cat: DtoCatalogueParams, pKey: string) => string;
-export declare const makeSelOptionsKey: (options: DtoSelectedOption[]) => string;
-export declare type RootNodeSource = DtoModel | File;
-export declare type CfgProductData = Omit<Omit<DtoProductData, "models">, "partsData"> & {
-    models?: RootNodeSource[];
-    partsData: Omit<DtoPartsData, "selOptions"> & {
-        selOptions: DtoSelectedOption[];
-    };
-};
-export declare type CfgProductResponse = Omit<DtoProductResponse, "productData"> & {
-    productData: CfgProductData;
-};
-/** This must be kept in sync with DtoValidateResponse. */
-export declare type CfgValidateResponse = Omit<DtoValidateResponse, "productData"> & {
-    productData: CfgProductData;
-};
-export declare function isModel(arg: unknown): arg is DtoModel;
-/** Replace empty strings with "-" for compatibility with the API. */
-export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParamsWithoutCid>(catId: T): T;
-export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: DtoPrices | undefined): number | undefined;
-export declare function comparePricesObjects(prices1: DtoPrices | undefined, prices2: DtoPrices | undefined): boolean;
-export declare const decodeCatalogueParams: <T extends DtoCatalogueParamsWithoutCid>(params: T) => T;
-export declare const decodeProductParams: <T extends DtoProductParams>(params: T) => T;
-export declare function isSameCatalogueParams(left: DtoCatalogueParamsWithoutCid, right: DtoCatalogueParamsWithoutCid): boolean;
-export declare function isSameVector(left: DtoVector, right: DtoVector): boolean;
-export declare function isSameOrientation(left: DtoOrientation, right: DtoOrientation): boolean;
-export declare function isSameAnchor(left: DtoMeasureParam, right: DtoMeasureParam): boolean;
-export declare function isSameTransform(left: DtoTransform, right: DtoTransform): boolean;
-export declare function isSameProductRef(left: DtoAdditionalProductRef, right: DtoAdditionalProductRef): boolean;
-export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithLang, right: DtoCatalogueParamsWithLang) => boolean;
-export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithLang, right: DtoProductParamsWithLang) => boolean;
+import { DtoAdditionalProductRef, DtoCatalogueParams, DtoCatalogueParamsWithLang, DtoCatalogueParamsWithoutCid, DtoMeasureParam, DtoModel, DtoOrientation, DtoPartsData, DtoPrices, DtoProductData, DtoProductParams, DtoProductParamsWithLang, DtoProductResponse, DtoSelectedOption, DtoTransform, DtoValidateResponse, DtoVector } from "./CatalogueAPI.js";
+export declare const makeCatalogueKey: (cat: DtoCatalogueParams) => string;
+export declare const makeProductKey: (cat: DtoCatalogueParams, pKey: string) => string;
+export declare const makeSelOptionsKey: (options: DtoSelectedOption[]) => string;
+export declare type RootNodeSource = DtoModel | File;
+export declare type CfgProductData = Omit<Omit<DtoProductData, "models">, "partsData"> & {
+    models?: RootNodeSource[];
+    partsData: Omit<DtoPartsData, "selOptions"> & {
+        selOptions: DtoSelectedOption[];
+    };
+};
+export declare type CfgProductResponse = Omit<DtoProductResponse, "productData"> & {
+    productData: CfgProductData;
+};
+/** This must be kept in sync with DtoValidateResponse. */
+export declare type CfgValidateResponse = Omit<DtoValidateResponse, "productData"> & {
+    productData: CfgProductData;
+};
+export declare function isModel(arg: unknown): arg is DtoModel;
+/** Replace empty strings with "-" for compatibility with the API. */
+export declare function correctDefaultsOnCatalogueParams<T extends DtoCatalogueParamsWithoutCid>(catId: T): T;
+export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: DtoPrices | undefined): number | undefined;
+export declare function comparePricesObjects(prices1: DtoPrices | undefined, prices2: DtoPrices | undefined): boolean;
+export declare const decodeCatalogueParams: <T extends DtoCatalogueParamsWithoutCid>(params: T) => T;
+export declare const decodeProductParams: <T extends DtoProductParams>(params: T) => T;
+export declare function isSameCatalogueParams(left: DtoCatalogueParamsWithoutCid, right: DtoCatalogueParamsWithoutCid): boolean;
+export declare function isSameVector(left: DtoVector, right: DtoVector): boolean;
+export declare function isSameOrientation(left: DtoOrientation, right: DtoOrientation): boolean;
+export declare function isSameAnchor(left: DtoMeasureParam, right: DtoMeasureParam): boolean;
+export declare function isSameTransform(left: DtoTransform, right: DtoTransform): boolean;
+export declare function isSameProductRef(left: DtoAdditionalProductRef, right: DtoAdditionalProductRef): boolean;
+export declare const isSameDtoCatalogueParamsWithLang: (left: DtoCatalogueParamsWithLang, right: DtoCatalogueParamsWithLang) => boolean;
+export declare const isSameDtoProductParamsWithLang: (left: DtoProductParamsWithLang, right: DtoProductParamsWithLang) => boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map

package/dist/utilitiesCatalogueData.js

@@ -1,164 +1,164 @@
-import { shallowCompareDictionaries } from "@configura/web-utilities";
-export const makeCatalogueKey = (cat) => `${cat.cid}-${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) => {
-    var _a;
-    const { code, numericValue, next } = option;
-    p += `_{${code}`;
-    p += 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 += "_}";
-    return p;
-}, "");
-export function isModel(arg) {
-    return typeof arg === "object" && arg !== null && "cid" in arg && "uri" in arg;
-}
-/** Replace empty strings with "-" for compatibility with the API. */
-export function correctDefaultsOnCatalogueParams(catId) {
-    // Enterprise, prdCat and vendor have to be set, so we don't try and fix those
-    return Object.assign(Object.assign({}, catId), { prdCatVersion: catId.prdCatVersion || "-", priceList: catId.priceList || "-" });
-}
-export function recursivelyGetPriceCodeValue(priceCodes, prices) {
-    while (prices) {
-        for (const name of priceCodes) {
-            const priceCodeUpcharge = prices === null || prices === void 0 ? void 0 : prices.values[name];
-            if (priceCodeUpcharge !== undefined) {
-                return priceCodeUpcharge;
-            }
-        }
-        prices = prices.parent;
-    }
-    return undefined;
-}
-export function comparePricesObjects(prices1, prices2) {
-    if (prices1 === undefined && prices2 === undefined) {
-        return true;
-    }
-    if (prices1 === undefined || prices2 === undefined) {
-        return false;
-    }
-    const parent1 = prices1.parent;
-    const parent2 = prices2.parent;
-    if (!comparePricesObjects(parent1, parent2)) {
-        return false;
-    }
-    return shallowCompareDictionaries(prices1.values, prices2.values);
-}
-export const decodeCatalogueParams = (params) => (Object.assign(Object.assign({}, params), { enterprise: decodeURIComponent(params.enterprise), prdCat: decodeURIComponent(params.prdCat), prdCatVersion: decodeURIComponent(params.prdCatVersion), priceList: decodeURIComponent(params.priceList), vendor: decodeURIComponent(params.vendor) }));
-export const decodeProductParams = (params) => (Object.assign(Object.assign({}, decodeCatalogueParams(params)), { partNumber: decodeURIComponent(params.partNumber) }));
-export function isSameCatalogueParams(left, right) {
-    return (left.enterprise === right.enterprise &&
-        left.prdCat === right.prdCat &&
-        left.prdCatVersion === right.prdCatVersion &&
-        left.priceList === right.priceList &&
-        left.vendor === right.vendor);
-}
-export function isSameVector(left, right) {
-    return left.x === right.x && left.y === right.y && left.z === right.z;
-}
-export function isSameOrientation(left, right) {
-    return left.pitch === right.pitch && left.roll === right.roll && left.yaw === right.yaw;
-}
-export function isSameAnchor(left, right) {
-    var _a, _b;
-    if (left.code !== right.code) {
-        return false;
-    }
-    if (left.anchorPoint !== right.anchorPoint) {
-        return false;
-    }
-    const leftMeasurePriorities = (_a = left.measurePriority) !== null && _a !== void 0 ? _a : [];
-    const rightMeasurePriorities = (_b = right.measurePriority) !== null && _b !== void 0 ? _b : [];
-    if (leftMeasurePriorities.length !== rightMeasurePriorities.length) {
-        return false;
-    }
-    if (leftMeasurePriorities.some((p, i) => p.url !== rightMeasurePriorities[i].url)) {
-        return false;
-    }
-    return true;
-}
-export function isSameTransform(left, right) {
-    const leftTransformPos = left.pos;
-    const rightTransformPos = right.pos;
-    const leftTransformRot = left.rot;
-    const rightTransformRot = right.rot;
-    const leftTransformScale = left.scale;
-    const rightTransformScale = right.scale;
-    if ((leftTransformPos === undefined) !== (rightTransformPos === undefined)) {
-        return false;
-    }
-    if ((leftTransformRot === undefined) !== (rightTransformRot === undefined)) {
-        return false;
-    }
-    if ((leftTransformScale === undefined) !== (rightTransformScale === undefined)) {
-        return false;
-    }
-    if (leftTransformPos !== undefined &&
-        rightTransformPos !== undefined &&
-        !isSameVector(leftTransformPos, rightTransformPos)) {
-        return false;
-    }
-    if (leftTransformRot !== undefined &&
-        rightTransformRot !== undefined &&
-        !isSameOrientation(leftTransformRot, rightTransformRot)) {
-        return false;
-    }
-    if (leftTransformScale !== undefined &&
-        rightTransformScale !== undefined &&
-        !isSameVector(leftTransformScale, rightTransformScale)) {
-        return false;
-    }
-    return true;
-}
-export function isSameProductRef(left, right) {
-    if (left.refKey !== right.refKey) {
-        return false;
-    }
-    if (left.partNumber !== right.partNumber) {
-        return false;
-    }
-    if (!isSameCatalogueParams(left.catId, right.catId)) {
-        return false;
-    }
-    if (left.refDescription !== right.refDescription) {
-        return false;
-    }
-    const leftAnchor = left.anchor;
-    const rightAnchor = right.anchor;
-    if ((leftAnchor === undefined) !== (rightAnchor === undefined)) {
-        return false;
-    }
-    if (leftAnchor !== undefined &&
-        rightAnchor !== undefined &&
-        !isSameAnchor(leftAnchor, rightAnchor)) {
-        return false;
-    }
-    const leftTransform = left.transform;
-    const rightTransform = right.transform;
-    if ((leftTransform === undefined) !== (rightTransform === undefined)) {
-        return false;
-    }
-    if (leftTransform !== undefined &&
-        rightTransform !== undefined &&
-        !isSameTransform(leftTransform, rightTransform)) {
-        return false;
-    }
-    if (left.optional !== right.optional) {
-        return false;
-    }
-    return true;
-}
-export const isSameDtoCatalogueParamsWithLang = (left, right) => left.cid === right.cid &&
-    left.lang === right.lang &&
-    left.enterprise === right.enterprise &&
-    left.prdCat === right.prdCat &&
-    left.prdCatVersion === right.prdCatVersion &&
-    left.priceList === right.priceList &&
-    left.vendor === right.vendor;
-export const isSameDtoProductParamsWithLang = (left, right) => isSameDtoCatalogueParamsWithLang(left, right) && left.partNumber === right.partNumber;
+import { shallowCompareDictionaries } from "@configura/web-utilities";
+export const makeCatalogueKey = (cat) => `${cat.cid}-${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) => {
+    var _a;
+    const { code, numericValue, next } = option;
+    p += `_{${code}`;
+    p += 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 += "_}";
+    return p;
+}, "");
+export function isModel(arg) {
+    return typeof arg === "object" && arg !== null && "cid" in arg && "uri" in arg;
+}
+/** Replace empty strings with "-" for compatibility with the API. */
+export function correctDefaultsOnCatalogueParams(catId) {
+    // Enterprise, prdCat and vendor have to be set, so we don't try and fix those
+    return Object.assign(Object.assign({}, catId), { prdCatVersion: catId.prdCatVersion || "-", priceList: catId.priceList || "-" });
+}
+export function recursivelyGetPriceCodeValue(priceCodes, prices) {
+    while (prices) {
+        for (const name of priceCodes) {
+            const priceCodeUpcharge = prices === null || prices === void 0 ? void 0 : prices.values[name];
+            if (priceCodeUpcharge !== undefined) {
+                return priceCodeUpcharge;
+            }
+        }
+        prices = prices.parent;
+    }
+    return undefined;
+}
+export function comparePricesObjects(prices1, prices2) {
+    if (prices1 === undefined && prices2 === undefined) {
+        return true;
+    }
+    if (prices1 === undefined || prices2 === undefined) {
+        return false;
+    }
+    const parent1 = prices1.parent;
+    const parent2 = prices2.parent;
+    if (!comparePricesObjects(parent1, parent2)) {
+        return false;
+    }
+    return shallowCompareDictionaries(prices1.values, prices2.values);
+}
+export const decodeCatalogueParams = (params) => (Object.assign(Object.assign({}, params), { enterprise: decodeURIComponent(params.enterprise), prdCat: decodeURIComponent(params.prdCat), prdCatVersion: decodeURIComponent(params.prdCatVersion), priceList: decodeURIComponent(params.priceList), vendor: decodeURIComponent(params.vendor) }));
+export const decodeProductParams = (params) => (Object.assign(Object.assign({}, decodeCatalogueParams(params)), { partNumber: decodeURIComponent(params.partNumber) }));
+export function isSameCatalogueParams(left, right) {
+    return (left.enterprise === right.enterprise &&
+        left.prdCat === right.prdCat &&
+        left.prdCatVersion === right.prdCatVersion &&
+        left.priceList === right.priceList &&
+        left.vendor === right.vendor);
+}
+export function isSameVector(left, right) {
+    return left.x === right.x && left.y === right.y && left.z === right.z;
+}
+export function isSameOrientation(left, right) {
+    return left.pitch === right.pitch && left.roll === right.roll && left.yaw === right.yaw;
+}
+export function isSameAnchor(left, right) {
+    var _a, _b;
+    if (left.code !== right.code) {
+        return false;
+    }
+    if (left.anchorPoint !== right.anchorPoint) {
+        return false;
+    }
+    const leftMeasurePriorities = (_a = left.measurePriority) !== null && _a !== void 0 ? _a : [];
+    const rightMeasurePriorities = (_b = right.measurePriority) !== null && _b !== void 0 ? _b : [];
+    if (leftMeasurePriorities.length !== rightMeasurePriorities.length) {
+        return false;
+    }
+    if (leftMeasurePriorities.some((p, i) => p.url !== rightMeasurePriorities[i].url)) {
+        return false;
+    }
+    return true;
+}
+export function isSameTransform(left, right) {
+    const leftTransformPos = left.pos;
+    const rightTransformPos = right.pos;
+    const leftTransformRot = left.rot;
+    const rightTransformRot = right.rot;
+    const leftTransformScale = left.scale;
+    const rightTransformScale = right.scale;
+    if ((leftTransformPos === undefined) !== (rightTransformPos === undefined)) {
+        return false;
+    }
+    if ((leftTransformRot === undefined) !== (rightTransformRot === undefined)) {
+        return false;
+    }
+    if ((leftTransformScale === undefined) !== (rightTransformScale === undefined)) {
+        return false;
+    }
+    if (leftTransformPos !== undefined &&
+        rightTransformPos !== undefined &&
+        !isSameVector(leftTransformPos, rightTransformPos)) {
+        return false;
+    }
+    if (leftTransformRot !== undefined &&
+        rightTransformRot !== undefined &&
+        !isSameOrientation(leftTransformRot, rightTransformRot)) {
+        return false;
+    }
+    if (leftTransformScale !== undefined &&
+        rightTransformScale !== undefined &&
+        !isSameVector(leftTransformScale, rightTransformScale)) {
+        return false;
+    }
+    return true;
+}
+export function isSameProductRef(left, right) {
+    if (left.refKey !== right.refKey) {
+        return false;
+    }
+    if (left.partNumber !== right.partNumber) {
+        return false;
+    }
+    if (!isSameCatalogueParams(left.catId, right.catId)) {
+        return false;
+    }
+    if (left.refDescription !== right.refDescription) {
+        return false;
+    }
+    const leftAnchor = left.anchor;
+    const rightAnchor = right.anchor;
+    if ((leftAnchor === undefined) !== (rightAnchor === undefined)) {
+        return false;
+    }
+    if (leftAnchor !== undefined &&
+        rightAnchor !== undefined &&
+        !isSameAnchor(leftAnchor, rightAnchor)) {
+        return false;
+    }
+    const leftTransform = left.transform;
+    const rightTransform = right.transform;
+    if ((leftTransform === undefined) !== (rightTransform === undefined)) {
+        return false;
+    }
+    if (leftTransform !== undefined &&
+        rightTransform !== undefined &&
+        !isSameTransform(leftTransform, rightTransform)) {
+        return false;
+    }
+    if (left.optional !== right.optional) {
+        return false;
+    }
+    return true;
+}
+export const isSameDtoCatalogueParamsWithLang = (left, right) => left.cid === right.cid &&
+    left.lang === right.lang &&
+    left.enterprise === right.enterprise &&
+    left.prdCat === right.prdCat &&
+    left.prdCatVersion === right.prdCatVersion &&
+    left.priceList === right.priceList &&
+    left.vendor === right.vendor;
+export const isSameDtoProductParamsWithLang = (left, right) => isSameDtoCatalogueParamsWithLang(left, right) && left.partNumber === right.partNumber;