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

package/dist/utilitiesCatalogueData.js

@@ -1,162 +1,173 @@
-import { shallowCompareDictionaries } from "@configura/web-utilities";
-export const makeCatalogueKey = (cat) => `${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 {
-        enterprise: catId.enterprise,
-        prdCat: catId.prdCat,
-        prdCatVersion: catId.prdCatVersion || "-",
-        priceList: catId.priceList || "-",
-        vendor: catId.vendor,
-    };
-}
-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;
-}
+import { shallowCompareDictionaries } from "@configura/web-utilities";
+/**
+ * Makes a string from the params which can be used as a key in for example React. Language is not respected.
+ */
+export const makeCatalogueKey = (cat) => `${cat.cid}-${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
+/**
+ * Makes a string from the params which can be used as a key in for example React. Language is not respected.
+ */
+export const makeProductKey = (prod) => `${makeCatalogueKey(prod)}-${prod.partNumber}`;
+/**
+ * Makes a string from selected options, can be used as a key for a selection.
+ */
+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;

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,38 +1,39 @@
-import { CatalogueParams, CataloguePermission } from "./CatalogueAPI.js";
-interface CataloguePermissionByEnterpriseKey {
-    [key: string]: CataloguePermission[];
-}
-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;
-/**
- * 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;
-/**
- * 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
- * permissions. If it fails to find any applicable permissions the original value is returned.
- * @param auth
- * @param params
- */
-export declare const getPrdCatVersionOrLatestFromPermissions: (params: CatalogueParams, cataloguePermissions: CataloguePermission[]) => 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
- * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
- * applicable auth-permissions the original value is returned.
- * @param auth
- * @param params
- */
-export declare const fillMissingPrdCatVersionFromPermissions: <T extends CatalogueParams>(params: T, cataloguePermissions: CataloguePermission[]) => T;
-export {};
+import { DtoCatalogueParams, DtoCataloguePermission } from "./CatalogueAPI.js";
+interface CataloguePermissionByEnterpriseKey {
+    [key: string]: DtoCataloguePermission[];
+}
+export declare const groupAndSortCataloguePermissions: (cataloguePermissions: DtoCataloguePermission[]) => CataloguePermissionByEnterpriseKey;
+export declare const isParamSet: (param: string | undefined) => boolean;
+export declare const createCataloguePermissionsFilter: (catParams: Partial<DtoCatalogueParams>) => (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.
+ */
+export declare const getPrdCatVersionFromPermissions: (cataloguePermissions: DtoCataloguePermission[], catParams: {
+    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
+ * permissions. If it fails to find any applicable permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+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
+ * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
+ * applicable auth-permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+export declare const fillMissingPrdCatVersionFromPermissions: <T extends DtoCatalogueParams>(params: T, cataloguePermissions: DtoCataloguePermission[]) => T;
+export {};
 //# sourceMappingURL=utilitiesCataloguePermission.d.ts.map

package/dist/utilitiesCataloguePermission.js

@@ -1,80 +1,79 @@
-export const groupAndSortCataloguePermissions = (cataloguePermissions) => {
-    const cataloguePermissionByEnterpriseKey = {};
-    cataloguePermissions
-        // Sort by enterprise
-        .sort((a, b) => a.enterprise.toLocaleLowerCase().localeCompare(b.enterprise.toLocaleLowerCase()))
-        .forEach((c) => {
-        const enterprise = c.enterprise.toLowerCase();
-        if (cataloguePermissionByEnterpriseKey[enterprise] === undefined) {
-            cataloguePermissionByEnterpriseKey[enterprise] = [];
-        }
-        cataloguePermissionByEnterpriseKey[enterprise].push(c);
-    });
-    // Sort by prdcat
-    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) &&
-    (!isParamSet(prdCat) || prdCat === perm.prdCat) &&
-    (!isParamSet(prdCatVersion) || prdCatVersion === perm.prdCatVersion) &&
-    (!isParamSet(vendor) ||
-        perm.vendors === undefined ||
-        perm.vendors.some((v) => vendor === v)) &&
-    (!isParamSet(priceList) ||
-        perm.priceLists === undefined ||
-        perm.priceLists.some((p) => priceList === p));
-/**
- * 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 const getPrdCatVersionFromPermissions = (cataloguePermissions, enterprise, prdCat, priceList, vendor) => {
-    const filter = createCataloguePermissionsFilter(enterprise, prdCat, "-", priceList, vendor);
-    const applicablePermissions = cataloguePermissions.filter(filter);
-    return applicablePermissions.reduce((pVersion, c) => {
-        const cVersion = c.prdCatVersion;
-        if (pVersion === undefined) {
-            return cVersion;
-        }
-        const pNum = parseFloat(pVersion);
-        const cNum = parseFloat(cVersion);
-        if (isNaN(pNum) || isNaN(cNum)) {
-            return pVersion < cVersion ? cVersion : pVersion;
-        }
-        return pNum < cNum ? cVersion : pVersion;
-    }, 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
- * permissions. If it fails to find any applicable permissions the original value is returned.
- * @param auth
- * @param params
- */
-export const getPrdCatVersionOrLatestFromPermissions = (params, cataloguePermissions) => {
-    const { enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
-    if (isParamSet(prdCatVersion)) {
-        return prdCatVersion;
-    }
-    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, enterprise, prdCat, priceList, vendor);
-    if (highestFoundVersion === undefined) {
-        return prdCatVersion;
-    }
-    return highestFoundVersion;
-};
-/**
- * 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
- * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
- * applicable auth-permissions the original value is returned.
- * @param auth
- * @param params
- */
-export const fillMissingPrdCatVersionFromPermissions = (params, cataloguePermissions) => (Object.assign(Object.assign({}, params), { prdCatVersion: getPrdCatVersionOrLatestFromPermissions(params, cataloguePermissions) }));
+export const groupAndSortCataloguePermissions = (cataloguePermissions) => {
+    const cataloguePermissionByEnterpriseKey = {};
+    cataloguePermissions
+        // Sort by enterprise
+        .sort((a, b) => a.enterprise.toLocaleLowerCase().localeCompare(b.enterprise.toLocaleLowerCase()))
+        .forEach((c) => {
+        const enterprise = c.enterprise.toLowerCase();
+        if (cataloguePermissionByEnterpriseKey[enterprise] === undefined) {
+            cataloguePermissionByEnterpriseKey[enterprise] = [];
+        }
+        cataloguePermissionByEnterpriseKey[enterprise].push(c);
+    });
+    // Sort by prdcat
+    Object.keys(cataloguePermissionByEnterpriseKey).forEach((enterprise) => cataloguePermissionByEnterpriseKey[enterprise].sort((a, b) => a.prdCat.toLocaleLowerCase().localeCompare(b.prdCat.toLocaleLowerCase())));
+    return cataloguePermissionByEnterpriseKey;
+};
+export const isParamSet = (param) => param !== undefined && param !== "" && param !== "-";
+export const createCataloguePermissionsFilter = (catParams) => {
+    const { cid, enterprise, prdCat, prdCatVersion, vendor, priceList } = catParams;
+    return (perm) => (cid === undefined || cid === perm.cid) &&
+        (!isParamSet(enterprise) || enterprise === perm.enterprise) &&
+        (!isParamSet(prdCat) || prdCat === perm.prdCat) &&
+        (!isParamSet(prdCatVersion) || prdCatVersion === perm.prdCatVersion) &&
+        (!isParamSet(vendor) ||
+            perm.vendors === undefined ||
+            perm.vendors.some((v) => vendor === v)) &&
+        (!isParamSet(priceList) ||
+            perm.priceLists === undefined ||
+            perm.priceLists.some((p) => priceList === p));
+};
+/**
+ * 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.
+ */
+export const getPrdCatVersionFromPermissions = (cataloguePermissions, catParams) => {
+    const filter = createCataloguePermissionsFilter(Object.assign(Object.assign({}, catParams), { prdCatVersion: undefined }));
+    const applicablePermissions = cataloguePermissions.filter(filter);
+    return applicablePermissions.reduce((pVersion, c) => {
+        const cVersion = c.prdCatVersion;
+        if (pVersion === undefined) {
+            return cVersion;
+        }
+        const pNum = parseFloat(pVersion);
+        const cNum = parseFloat(cVersion);
+        if (isNaN(pNum) || isNaN(cNum)) {
+            return pVersion < cVersion ? cVersion : pVersion;
+        }
+        return pNum < cNum ? cVersion : pVersion;
+    }, 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
+ * permissions. If it fails to find any applicable permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+export const getPrdCatVersionOrLatestFromPermissions = (params, cataloguePermissions) => {
+    const { prdCatVersion } = params;
+    if (isParamSet(prdCatVersion)) {
+        return prdCatVersion;
+    }
+    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, params);
+    if (highestFoundVersion === undefined) {
+        return prdCatVersion;
+    }
+    return highestFoundVersion;
+};
+/**
+ * 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
+ * cataloguePermissions and insert it into a copy of the original params. If it fails to find any
+ * applicable auth-permissions the original value is returned.
+ * @param auth
+ * @param params
+ */
+export const fillMissingPrdCatVersionFromPermissions = (params, cataloguePermissions) => (Object.assign(Object.assign({}, params), { prdCatVersion: getPrdCatVersionOrLatestFromPermissions(params, cataloguePermissions) }));

package/dist/utilitiesNumericValues.d.ts

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