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

package/dist/productConfiguration/utilitiesProductConfiguration.d.ts

@@ -1,4 +1,4 @@
-import { AdditionalProductRef, Feature, FeatureRef } from "../CatalogueAPI.js";
+import { DtoAdditionalProductRef, DtoFeature, DtoFeatureRef } from "../CatalogueAPI.js";
 import { _CfgProductInternal } from "../CfgProduct.js";
 import { CfgMtrlApplication } from "../material/CfgMtrlApplication.js";
 import { CfgFeature } from "./CfgFeature.js";
@@ -8,11 +8,11 @@ import { CfgProductConfiguration, _CfgProductConfigurationInternal } from "./Cfg
  * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
  * currentFeatures if they can be found, otherwise makes new.
  */
-export declare function syncCfgFeatures(newFeatureRefs: FeatureRef[], currentFeatures: CfgFeature[], allRawFeatures: Feature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
+export declare function syncCfgFeatures(newFeatureRefs: DtoFeatureRef[], currentFeatures: CfgFeature[], allRawFeatures: DtoFeature[], parent: _CfgProductConfigurationInternal | _CfgOptionInternal, parentConfiguration: _CfgProductConfigurationInternal, parentProduct: _CfgProductInternal, rootProduct: _CfgProductInternal): CfgFeature[];
 export declare function getMtrlPreview(mtrlApplications: CfgMtrlApplication[] | undefined): string | undefined;
 /**
  * Recursively find all additional product references given a product configuration.
  * Only selected options are considered.
  */
-export declare function collectAdditionalProductRefs(parent: CfgProductConfiguration): AdditionalProductRef[];
+export declare function collectAdditionalProductRefs(parent: CfgProductConfiguration): DtoAdditionalProductRef[];
 //# sourceMappingURL=utilitiesProductConfiguration.d.ts.map

package/dist/productLoader.d.ts

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

package/dist/syncGroups/SyncGroupsHandler.js

@@ -240,12 +240,13 @@ import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
  */
 function notifyOptionAndSelectedSiblings(option) {
     return __awaiter(this, void 0, void 0, function* () {
+        const committed = false;
         const parentFeature = option.parent;
         if (parentFeature.selectionType === SelectionType.SelectOne) {
             // These only need to be OneLevel, as the final is ToRoot and they share their parent.
-            yield Promise.all(option.parent.selectedOptions.map((o) => parentFeature._childHasChanged(o._internal, ProductConfigurationBubbleMode.OneLevel)));
+            yield Promise.all(option.parent.selectedOptions.map((o) => parentFeature._childHasChanged(o._internal, ProductConfigurationBubbleMode.OneLevel, committed)));
         }
-        yield parentFeature._childHasChanged(option, ProductConfigurationBubbleMode.ToRoot);
+        yield parentFeature._childHasChanged(option, ProductConfigurationBubbleMode.ToRoot, committed);
     });
 }
 /**

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -167,7 +167,7 @@ export class SyncGroupsTransaction {
             }
             const promises = [];
             for (const product of productsToValidate) {
-                promises.push(product._revalidate(CfgProductBubbleMode.ToRoot, this.productLoader));
+                promises.push(product._revalidate(CfgProductBubbleMode.ToRoot, this.productLoader, true));
             }
             const revalidationResults = yield Promise.all(promises);
             if (revalidationResults.every((r) => !r)) {

package/dist/tasks/TaskHandler.d.ts

@@ -1,16 +1,15 @@
 import { Observable, SingleArgCallback } from "@configura/web-utilities";
-import { AdditionalProductConfiguration, CatalogueAPI, ExportStatus, ExportStatusStatus, PostExportParams, PostRenderParams, RenderStatus, RenderStatusStatus, TargetCameraArgs } from "../CatalogueAPI.js";
+import { CatalogueAPI, DtoAdditionalProductConfiguration, DtoExportStatus, DtoExportStatusStatus, DtoProductParamsWithLang, DtoRenderStatus, DtoRenderStatusStatus, DtoTargetCameraArgs } from "../CatalogueAPI.js";
 import { CfgProduct } from "../CfgProduct.js";
 import { RenderOrExportFormat } from "./formats.js";
 export declare type TasksChangeNotification = {
     freshRef: TaskHandler;
 };
 export declare type RenderTaskParams = {
-    targetCameraArgs?: TargetCameraArgs;
+    targetCameraArgs?: DtoTargetCameraArgs;
     width: number;
     height: number;
 };
-export declare type ProductParams = PostRenderParams | PostExportParams;
 export declare class _TaskHandlerInternal {
     api: CatalogueAPI;
     readonly changeObservable: Observable<TasksChangeNotification>;
@@ -44,16 +43,16 @@ export declare class TaskHandler {
     listenForChange: (l: SingleArgCallback<TasksChangeNotification>) => void;
     stopListenForChange: (l: SingleArgCallback<TasksChangeNotification>) => void;
 }
-declare type TaskStatus = RenderStatusStatus | ExportStatusStatus | "abandoned";
+declare type TaskStatus = DtoRenderStatusStatus | DtoExportStatusStatus | "abandoned";
 export declare abstract class Task<F extends RenderOrExportFormat> {
     protected readonly taskHandler: _TaskHandlerInternal;
     readonly format: F;
     private _timerId;
     protected constructor(taskHandler: _TaskHandlerInternal, format: F, product: CfgProduct, getPreviewUrl: (() => Promise<string>) | undefined);
-    protected abstract postInit(): Promise<RenderStatus | ExportStatus>;
-    protected abstract pollStatus(): Promise<RenderStatus | ExportStatus>;
-    protected _productParams: ProductParams;
-    protected _apiSelection: AdditionalProductConfiguration;
+    protected abstract postInit(): Promise<DtoRenderStatus | DtoExportStatus>;
+    protected abstract pollStatus(): Promise<DtoRenderStatus | DtoExportStatus>;
+    protected _productParams: DtoProductParamsWithLang;
+    protected _apiSelection: DtoAdditionalProductConfiguration;
     private _status;
     private _uuid;
     private _created;

package/dist/tasks/TaskHandler.js

@@ -8,9 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { augmentErrorMessage, Observable } from "@configura/web-utilities";
-import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
+import { dtoExportFormatNames, dtoRenderFormatNames, } 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) {
         this.api = api;
@@ -56,10 +55,10 @@ export class _TaskHandlerInternal {
     get availableFormats() {
         const result = [];
         if (this.hasExport) {
-            result.push(...exportFormatNames);
+            result.push(...dtoExportFormatNames);
         }
         if (this.hasRender) {
-            result.push(...renderFormatNames);
+            result.push(...dtoRenderFormatNames);
         }
         return result;
     }
@@ -175,7 +174,7 @@ export class Task {
             this.stop();
             this.taskHandler.removeTask(this);
         };
-        this._productParams = productToParams(product);
+        this._productParams = product.prodParams;
         this._apiSelection = product.getApiSelection();
         if (getPreviewUrl !== undefined) {
             void getPreviewUrl().then((dataUrl) => {

package/dist/tasks/formats.d.ts

@@ -1,5 +1,5 @@
-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;
+import { DtoExportFormat, DtoRenderFormat } from "../CatalogueAPI.js";
+export declare type RenderOrExportFormat = DtoRenderFormat | DtoExportFormat;
+export declare function isRenderFormat(type: unknown): type is DtoRenderFormat;
+export declare function isExportFormat(type: unknown): type is DtoExportFormat;
 //# sourceMappingURL=formats.d.ts.map

package/dist/tasks/formats.js

@@ -1,7 +1,7 @@
-import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
+import { dtoExportFormatNames, dtoRenderFormatNames, } from "../CatalogueAPI.js";
 export function isRenderFormat(type) {
-    return renderFormatNames.some((f) => type === f);
+    return dtoRenderFormatNames.some((f) => type === f);
 }
 export function isExportFormat(type) {
-    return exportFormatNames.some((f) => type === f);
+    return dtoExportFormatNames.some((f) => type === f);
 }

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

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

package/dist/tests/testData/dummyProductForTest.js

@@ -1,5 +1,7 @@
 import { CfgProduct } from "../../CfgProduct.js";
 export const dummyCatId = {
+    cid: 123,
+    lang: "lang",
     enterprise: "enterprise",
     prdCat: "prdCat",
     prdCatVersion: "prdCatVersion",
@@ -27,10 +29,4 @@ export const getDummyCfgProduct = () => CfgProduct.make({
     postValidate: () => {
         throw new Error("Should not be used");
     },
-}, "lang", {
-    enterprise: "enterprise",
-    prdCat: "prdCat",
-    prdCatVersion: "prdCatVersion",
-    priceList: "priceList",
-    vendor: "vendor",
-}, "partNumber");
+}, Object.assign(Object.assign({}, dummyCatId), { partNumber: "partNumber" }));

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

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

package/dist/tests/testData/testDataAdditionalProductInAdditionalProductInProductForTest.js

@@ -258,7 +258,7 @@ export const cfgProductTest = (testFunc, prepFunc) => __awaiter(void 0, void 0,
             collect.pushNotification(`Validate ${params.enterprise} ${params.prdCat} ${params.prdCatVersion} ${params.priceList} ${params.vendor} ${params.partNumber}`);
             return validateResponse;
         }),
-    }, "lang", dummyCatId, "A");
+    }, Object.assign(Object.assign({}, dummyCatId), { partNumber: "A" }));
     if (prepFunc !== undefined) {
         yield prepFunc(product);
     }

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

@@ -1,6 +1,6 @@
-import { GetProductParams } from "../../CatalogueAPI.js";
+import { DtoGetProductParams } from "../../CatalogueAPI.js";
 import { CfgProduct } from "../../CfgProduct.js";
 import { CfgProductResponse } from "../../utilitiesCatalogueData.js";
-export declare const getTestProduct: (params: GetProductParams, validateCall?: boolean | undefined) => Promise<CfgProductResponse>;
+export declare const getTestProduct: (params: DtoGetProductParams, validateCall?: boolean | undefined) => Promise<CfgProductResponse>;
 export declare const cachedProductLoaderTest: () => Promise<CfgProduct>;
 //# sourceMappingURL=testDataCachedGetProduct.d.ts.map

package/dist/tests/testData/testDataCachedGetProduct.js

@@ -180,6 +180,6 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
     const productWrapper = yield CfgProduct.make({
         getProduct: wrapWithGetProductCache(productLoader.getProduct.bind(productLoader)),
         postValidate: productLoader.postValidate.bind(productLoader),
-    }, "lang", dummyCatId, "A");
+    }, Object.assign(Object.assign({}, dummyCatId), { partNumber: "A" }));
     return productWrapper;
 });

package/dist/tests/testData/testDataCachedPostValidate.js

@@ -178,6 +178,6 @@ export const cachedProductLoaderTest = () => __awaiter(void 0, void 0, void 0, f
             return validateResponse;
         }),
     };
-    const product = yield CfgProduct.make(productLoader, "lang", dummyCatId, "Table");
+    const product = yield CfgProduct.make(productLoader, Object.assign(Object.assign({}, dummyCatId), { partNumber: "Table" }));
     return { product, validateCounter };
 });

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

@@ -1,13 +1,13 @@
-import { Option, SelectedOption } from "../../CatalogueAPI.js";
-export declare function addDefaultsToMockSelectedOption(root: SelectedOption, optionCodeToAdd: string | undefined, optionCodesToRemove: string[], unlessOptionCodes: string[]): void;
+import { DtoOption, DtoSelectedOption } from "../../CatalogueAPI.js";
+export declare function addDefaultsToMockSelectedOption(root: DtoSelectedOption, 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 letterOptions: DtoOption[];
 export declare const toggleOptionCodeOff = "optOff";
 export declare const toggleOptionCodeOn = "optOn";
-export declare const toggleOptions: Option[];
+export declare const toggleOptions: DtoOption[];
 //# sourceMappingURL=testDataOptions.d.ts.map

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

@@ -1,7 +1,7 @@
-import { GetProductParams, SelectedOption } from "../../CatalogueAPI.js";
+import { DtoGetProductParams, DtoSelectedOption } 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 getTestProduct: (params: DtoGetProductParams) => Promise<CfgProductResponse>;
+export declare function getSelOptions(option: string): DtoSelectedOption[];
 export declare const cfgProductPriceTest: (testFunc?: ((cfgProduct: CfgProduct) => Promise<void>) | undefined, featureOption?: string | undefined) => Promise<CfgProduct>;
 //# sourceMappingURL=testDataProductAggregatedPrice.d.ts.map

package/dist/tests/testData/testDataProductAggregatedPrice.js

@@ -179,7 +179,7 @@ export const cfgProductPriceTest = (testFunc, featureOption) => __awaiter(void 0
             };
             return validateResponse;
         }),
-    }, "lang", dummyCatId, "A");
+    }, Object.assign(Object.assign({}, dummyCatId), { partNumber: "A" }));
     if (testFunc !== undefined) {
         yield testFunc(cfgProduct);
     }

package/dist/tests/testData/testDataUpcharge.js

@@ -103,7 +103,7 @@ export const getUpchargeProduct = (testFunc) => __awaiter(void 0, void 0, void 0
             return validateResponse;
         }),
     };
-    const product = yield CfgProduct.make(productLoader, "lang", dummyCatId, "Table");
+    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);

package/dist/utilitiesCatalogueData.d.ts

@@ -1,32 +1,34 @@
-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;
-export declare type RootNodeSource = Model | File;
-export declare type CfgProductData = Omit<Omit<ProductData, "models">, "partsData"> & {
+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<PartsData, "selOptions"> & {
-        selOptions: SelectedOption[];
+    partsData: Omit<DtoPartsData, "selOptions"> & {
+        selOptions: DtoSelectedOption[];
     };
 };
-export declare type CfgProductResponse = Omit<ProductResponse, "productData"> & {
+export declare type CfgProductResponse = Omit<DtoProductResponse, "productData"> & {
     productData: CfgProductData;
 };
-/** This must be kept in sync with ValidateResponse. */
-export declare type CfgValidateResponse = Omit<ValidateResponse, "productData"> & {
+/** 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 Model;
+export declare function isModel(arg: unknown): arg is DtoModel;
 /** Replace empty strings with "-" for compatibility with the API. */
-export declare function correctDefaultsOnCatalogueParams(catId: CatalogueParams): CatalogueParams;
-export declare function recursivelyGetPriceCodeValue(priceCodes: string[], prices: Prices | undefined): number | undefined;
-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;
+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,5 +1,5 @@
 import { shallowCompareDictionaries } from "@configura/web-utilities";
-export const makeCatalogueKey = (cat) => `${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
+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;
@@ -22,13 +22,7 @@ export function isModel(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 {
-        enterprise: catId.enterprise,
-        prdCat: catId.prdCat,
-        prdCatVersion: catId.prdCatVersion || "-",
-        priceList: catId.priceList || "-",
-        vendor: catId.vendor,
-    };
+    return Object.assign(Object.assign({}, catId), { prdCatVersion: catId.prdCatVersion || "-", priceList: catId.priceList || "-" });
 }
 export function recursivelyGetPriceCodeValue(priceCodes, prices) {
     while (prices) {
@@ -160,3 +154,11 @@ export function isSameProductRef(left, right) {
     }
     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;

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,22 +1,17 @@
-import { CatalogueParams, CataloguePermission } from "./CatalogueAPI.js";
+import { DtoCatalogueParams, DtoCataloguePermission } from "./CatalogueAPI.js";
 interface CataloguePermissionByEnterpriseKey {
-    [key: string]: CataloguePermission[];
+    [key: string]: DtoCataloguePermission[];
 }
-export declare const groupAndSortCataloguePermissions: (cataloguePermissions: CataloguePermission[]) => CataloguePermissionByEnterpriseKey;
-export declare const isParamSet: (param: string) => boolean;
-export declare const createCataloguePermissionsFilter: (enterprise: string, prdCat: string, prdCatVersion: string, priceList: string, vendor: string) => (perm: CataloguePermission) => boolean;
+export declare const groupAndSortCataloguePermissions: (cataloguePermissions: DtoCataloguePermission[]) => CataloguePermissionByEnterpriseKey;
+export declare const isParamSet: (param: string | undefined) => boolean;
+export declare const createCataloguePermissionsFilter: (cid: number | undefined, enterprise: string | undefined, prdCat: string | undefined, prdCatVersion: string | undefined, priceList: string | undefined, vendor: string | undefined) => (perm: DtoCataloguePermission) => boolean;
 /**
  * Sometimes you will want to use the latest available prdCatVersion. This method will
  * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
  * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
  * string compare.
- * @param cataloguePermissions
- * @param enterprise
- * @param prdCat
- * @param priceList
- * @param vendor
  */
-export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: CataloguePermission[], enterprise: string, prdCat: string, priceList: string, vendor: string) => string | undefined;
+export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: DtoCataloguePermission[], cid: number | undefined, enterprise: string | undefined, prdCat: string | undefined, priceList: string | undefined, vendor: string | undefined) => string | undefined;
 /**
  * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
  * This method will, if the prdCatVersion is not set, fetch the highest available from the catalogue
@@ -24,7 +19,7 @@ export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: Cat
  * @param auth
  * @param params
  */
-export declare const getPrdCatVersionOrLatestFromPermissions: (params: CatalogueParams, cataloguePermissions: CataloguePermission[]) => string;
+export declare const getPrdCatVersionOrLatestFromPermissions: (params: DtoCatalogueParams, cataloguePermissions: DtoCataloguePermission[]) => string;
 /**
  * Sometimes you will want a missing prdCatVersion to represent "Get the current highest version".
  * This method will, if the prdCatVersion is not set, fetch the highest available from the
@@ -33,6 +28,6 @@ export declare const getPrdCatVersionOrLatestFromPermissions: (params: Catalogue
  * @param auth
  * @param params
  */
-export declare const fillMissingPrdCatVersionFromPermissions: <T extends CatalogueParams>(params: T, cataloguePermissions: CataloguePermission[]) => T;
+export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParams>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
 export {};
 //# sourceMappingURL=utilitiesCataloguePermission.d.ts.map

package/dist/utilitiesCataloguePermission.js

@@ -14,8 +14,9 @@ export const groupAndSortCataloguePermissions = (cataloguePermissions) => {
     Object.keys(cataloguePermissionByEnterpriseKey).forEach((enterprise) => cataloguePermissionByEnterpriseKey[enterprise].sort((a, b) => a.prdCat.toLocaleLowerCase().localeCompare(b.prdCat.toLocaleLowerCase())));
     return cataloguePermissionByEnterpriseKey;
 };
-export const isParamSet = (param) => param !== "" && param !== "-";
-export const createCataloguePermissionsFilter = (enterprise, prdCat, prdCatVersion, priceList, vendor) => (perm) => (!isParamSet(enterprise) || enterprise === perm.enterprise) &&
+export const isParamSet = (param) => param !== undefined && param !== "" && param !== "-";
+export const createCataloguePermissionsFilter = (cid, enterprise, prdCat, prdCatVersion, priceList, vendor) => (perm) => (cid === undefined || cid === perm.cid) &&
+    (!isParamSet(enterprise) || enterprise === perm.enterprise) &&
     (!isParamSet(prdCat) || prdCat === perm.prdCat) &&
     (!isParamSet(prdCatVersion) || prdCatVersion === perm.prdCatVersion) &&
     (!isParamSet(vendor) ||
@@ -29,14 +30,9 @@ export const createCataloguePermissionsFilter = (enterprise, prdCat, prdCatVersi
  * find the highest prdCatVersion version in the cataloguePermissions. If the versions are
  * numeric ("1", "4.3", "0.2") they will be numerically compared, otherwise non localized
  * string compare.
- * @param cataloguePermissions
- * @param enterprise
- * @param prdCat
- * @param priceList
- * @param vendor
  */
-export const getPrdCatVersionFromPermissions = (cataloguePermissions, enterprise, prdCat, priceList, vendor) => {
-    const filter = createCataloguePermissionsFilter(enterprise, prdCat, "-", priceList, vendor);
+export const getPrdCatVersionFromPermissions = (cataloguePermissions, cid, enterprise, prdCat, priceList, vendor) => {
+    const filter = createCataloguePermissionsFilter(cid, enterprise, prdCat, "-", priceList, vendor);
     const applicablePermissions = cataloguePermissions.filter(filter);
     return applicablePermissions.reduce((pVersion, c) => {
         const cVersion = c.prdCatVersion;
@@ -59,11 +55,11 @@ export const getPrdCatVersionFromPermissions = (cataloguePermissions, enterprise
  * @param params
  */
 export const getPrdCatVersionOrLatestFromPermissions = (params, cataloguePermissions) => {
-    const { enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
+    const { cid, enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
     if (isParamSet(prdCatVersion)) {
         return prdCatVersion;
     }
-    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, enterprise, prdCat, priceList, vendor);
+    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, cid, enterprise, prdCat, priceList, vendor);
     if (highestFoundVersion === undefined) {
         return prdCatVersion;
     }

package/dist/utilitiesNumericValues.d.ts

@@ -1,6 +1,6 @@
-import { CodeRange } from "./CatalogueAPI.js";
+import { DtoCodeRange } from "./CatalogueAPI.js";
 export declare class NumericValuesSelection {
-    constructor(rawRanges: CodeRange[]);
+    constructor(rawRanges: DtoCodeRange[]);
     readonly ranges: (NumericValueRangeDefinition | NumericValueDiscrete)[];
     includesValue(value: number): boolean;
     get first(): number;
@@ -14,7 +14,7 @@ export declare class NumericValueDiscrete {
     get legend(): string;
 }
 export declare class NumericValueRangeDefinition {
-    constructor(rawRange: CodeRange);
+    constructor(rawRange: DtoCodeRange);
     readonly minValue: number;
     readonly maxValue: number;
     readonly increment: number | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/web-api",
-	"version": "1.6.1",
+	"version": "2.0.0-alpha.0",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "1.6.1"
+		"@configura/web-utilities": "2.0.0-alpha.0"
 	},
-	"gitHead": "bffef8762f32d8629a89837cafc20d34702409a3"
+	"gitHead": "b802ecc481c41f8dd8342dc6eaf5010a86f0f85d"
 }