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

package/dist/utilitiesCataloguePermission.d.ts

@@ -1,33 +1,33 @@
-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: (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.
- */
-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
- * 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 {};
+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: (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.
+ */
+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
+ * 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,76 +1,76 @@
-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 = (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) ||
-        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, 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;
-        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 { cid, enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
-    if (isParamSet(prdCatVersion)) {
-        return prdCatVersion;
-    }
-    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, cid, 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 = (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) ||
+        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, 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;
+        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 { cid, enterprise, prdCat, prdCatVersion, priceList, vendor } = params;
+    if (isParamSet(prdCatVersion)) {
+        return prdCatVersion;
+    }
+    const highestFoundVersion = getPrdCatVersionFromPermissions(cataloguePermissions, cid, 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) }));

package/dist/utilitiesNumericValues.d.ts

@@ -1,25 +1,25 @@
-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;
-}
+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

package/dist/utilitiesNumericValues.js

@@ -1,109 +1,109 @@
-/** Rounds the supplied value to 3 decimal points. */
-function round(v) {
-    return Math.round(v * 1000) / 1000;
-}
-export class NumericValuesSelection {
-    constructor(rawRanges) {
-        if (rawRanges.length === 0) {
-            throw new Error("A numeric values selection must have at least one value");
-        }
-        this.ranges = rawRanges.map((rawRange) => {
-            const { minValue, maxValue } = rawRange;
-            if (minValue === maxValue) {
-                return new NumericValueDiscrete(minValue);
-            }
-            else {
-                return new NumericValueRangeDefinition(rawRange);
-            }
-        });
-    }
-    includesValue(value) {
-        return this.ranges.some((range) => range.includesValue(value));
-    }
-    get first() {
-        return this.ranges[0].first;
-    }
-    get legend() {
-        return this.ranges
-            .sort((l, r) => l.first - r.first)
-            .map((range) => range.legend)
-            .join(", ");
-    }
-}
-export class NumericValueDiscrete {
-    constructor(value) {
-        this.value = value;
-    }
-    includesValue(value) {
-        return value === this.value;
-    }
-    get first() {
-        return this.value;
-    }
-    get legend() {
-        return `${round(this.value)}`;
-    }
-}
-export class NumericValueRangeDefinition {
-    constructor(rawRange) {
-        const { minValue, maxValue, increment } = rawRange;
-        this.minValue = minValue;
-        this.maxValue = maxValue;
-        this.increment = increment === 0 ? undefined : increment;
-    }
-    includesValue(value) {
-        const { minValue: start, maxValue: end, increment: step } = this;
-        if (value < start || end < value) {
-            return false;
-        }
-        // TODO: This comparison will often fail due to the fact that all the values used are
-        // base-2 (binary) floating point numbers based on base-10 (decimal) input strings.
-        //
-        // Such calculations are often not 100% accurate as is visible in JS by simply
-        // computing "0.1 + 0.2" which should equal about "0.30000000000000004" != "0.3".
-        //
-        // The easiest workaround is to define an static accuracy, say "6 decimals" and round
-        // everything when comparing. One could also use a scaled version of Number.EPSILON to
-        // dynamically match the precision to the precision of the input numbers.
-        //
-        // Both workarounds share the same problem however; an infinite number of numbers will be
-        // included in the range since an "infinite" number of values will map to the same rounded
-        // actual number.
-        //
-        // The proper fix is probably to use a fixed point mathematics, where we either define a
-        // maximum of say 6 decimals or the number of decimals vary on the number of decimals given
-        // in the JSON for each value.
-        //
-        // This should work given that the input in CatCreator is decimal (human created string) and
-        // both XML and JSON uses string based decimal numbers. One question mark remains however,
-        // and that is how the numbers are stored in CatCreator if you use a db3-file. If it is a
-        // string there as well, everything is dandy. Otherwise we might get problems with rounding
-        // or infinite decimals during the conversions to/from the db3-file.
-        return step === undefined || (value - start) % step === 0;
-    }
-    get first() {
-        return this.minValue;
-    }
-    get legend() {
-        const { minValue, maxValue, increment } = this;
-        if (increment === undefined) {
-            return `[${round(minValue)} ... ${round(maxValue)}]`;
-        }
-        const steps = 1 + Math.floor((maxValue - minValue) / increment);
-        let legend = `[${round(minValue)}`;
-        if (increment !== undefined && 3 <= steps) {
-            legend += `, ${round(minValue + increment)}`;
-        }
-        if (5 <= steps) {
-            legend += " ... ";
-        }
-        else {
-            legend += ", ";
-        }
-        if (4 <= steps) {
-            legend += `${round(minValue + increment * (steps - 2))}, `;
-        }
-        legend += `${round(minValue + increment * (steps - 1))}]`;
-        return legend;
-    }
-}
+/** Rounds the supplied value to 3 decimal points. */
+function round(v) {
+    return Math.round(v * 1000) / 1000;
+}
+export class NumericValuesSelection {
+    constructor(rawRanges) {
+        if (rawRanges.length === 0) {
+            throw new Error("A numeric values selection must have at least one value");
+        }
+        this.ranges = rawRanges.map((rawRange) => {
+            const { minValue, maxValue } = rawRange;
+            if (minValue === maxValue) {
+                return new NumericValueDiscrete(minValue);
+            }
+            else {
+                return new NumericValueRangeDefinition(rawRange);
+            }
+        });
+    }
+    includesValue(value) {
+        return this.ranges.some((range) => range.includesValue(value));
+    }
+    get first() {
+        return this.ranges[0].first;
+    }
+    get legend() {
+        return this.ranges
+            .sort((l, r) => l.first - r.first)
+            .map((range) => range.legend)
+            .join(", ");
+    }
+}
+export class NumericValueDiscrete {
+    constructor(value) {
+        this.value = value;
+    }
+    includesValue(value) {
+        return value === this.value;
+    }
+    get first() {
+        return this.value;
+    }
+    get legend() {
+        return `${round(this.value)}`;
+    }
+}
+export class NumericValueRangeDefinition {
+    constructor(rawRange) {
+        const { minValue, maxValue, increment } = rawRange;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+        this.increment = increment === 0 ? undefined : increment;
+    }
+    includesValue(value) {
+        const { minValue: start, maxValue: end, increment: step } = this;
+        if (value < start || end < value) {
+            return false;
+        }
+        // TODO: This comparison will often fail due to the fact that all the values used are
+        // base-2 (binary) floating point numbers based on base-10 (decimal) input strings.
+        //
+        // Such calculations are often not 100% accurate as is visible in JS by simply
+        // computing "0.1 + 0.2" which should equal about "0.30000000000000004" != "0.3".
+        //
+        // The easiest workaround is to define an static accuracy, say "6 decimals" and round
+        // everything when comparing. One could also use a scaled version of Number.EPSILON to
+        // dynamically match the precision to the precision of the input numbers.
+        //
+        // Both workarounds share the same problem however; an infinite number of numbers will be
+        // included in the range since an "infinite" number of values will map to the same rounded
+        // actual number.
+        //
+        // The proper fix is probably to use a fixed point mathematics, where we either define a
+        // maximum of say 6 decimals or the number of decimals vary on the number of decimals given
+        // in the JSON for each value.
+        //
+        // This should work given that the input in CatCreator is decimal (human created string) and
+        // both XML and JSON uses string based decimal numbers. One question mark remains however,
+        // and that is how the numbers are stored in CatCreator if you use a db3-file. If it is a
+        // string there as well, everything is dandy. Otherwise we might get problems with rounding
+        // or infinite decimals during the conversions to/from the db3-file.
+        return step === undefined || (value - start) % step === 0;
+    }
+    get first() {
+        return this.minValue;
+    }
+    get legend() {
+        const { minValue, maxValue, increment } = this;
+        if (increment === undefined) {
+            return `[${round(minValue)} ... ${round(maxValue)}]`;
+        }
+        const steps = 1 + Math.floor((maxValue - minValue) / increment);
+        let legend = `[${round(minValue)}`;
+        if (increment !== undefined && 3 <= steps) {
+            legend += `, ${round(minValue + increment)}`;
+        }
+        if (5 <= steps) {
+            legend += " ... ";
+        }
+        else {
+            legend += ", ";
+        }
+        if (4 <= steps) {
+            legend += `${round(minValue + increment * (steps - 2))}, `;
+        }
+        legend += `${round(minValue + increment * (steps - 1))}]`;
+        return legend;
+    }
+}

package/package.json

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