@configura/web-api 2.0.0-alpha.9 → 2.0.0

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,114 @@
-/** 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)}`;
+    }
+}
+const ACCEPTABLE_STEP_DEVIATION = 0.0000001;
+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;
+        }
+        // This comparison would 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".
+        //
+        // We have used the easiest workaround, to simply be a bit fuzzy with the checks and
+        // allow values that are very, very close to being on a step.
+        //
+        // This workaround comes with two major compromises:
+        // 1. The fuzziness needed depends on how many steps the checked values pass on the way.
+        // 2. An infinite number of numbers will be included in the range since many an "infinite"
+        //    number of values close to each step will map to it.
+        //
+        // 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.
+        if (step === undefined) {
+            return true;
+        }
+        const deviation = (value - start) % step;
+        return (deviation < ACCEPTABLE_STEP_DEVIATION || step - deviation < ACCEPTABLE_STEP_DEVIATION);
+    }
+    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.9",
+	"version": "2.0.0",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "2.0.0-alpha.9"
+		"@configura/web-utilities": "2.0.0"
 	},
-	"gitHead": "734f4e65f7d3dc9836c5c0321dbe6c36bbfa2531"
+	"gitHead": "efc959fe673f0ef172d332fae1bd53093f88b134"
 }