@utiliread/primitives 1.0.0-6 → 1.0.0-60

package/locales/en/units.json

@@ -0,0 +1,90 @@
+{
+    "unitless": [""],
+
+    "milliWattHour": ["mWh"],
+    "wattHour": ["Wh"],
+    "kiloWattHour": ["kWh"],
+    "megaWattHour": ["MWh"],
+    "gigaWattHour": ["GWh"],
+    "calorie": ["cal"],
+    "kiloCalorie": ["kcal"],
+    "megaCalorie": ["Mcal"],
+
+    "joule": ["J"],
+    "kiloJoule": ["kJ"],
+    "megaJoule": ["MJ"],
+    "gigaJoule": ["GJ"],
+    
+    "liter": ["L"],
+    "cubicMeter": ["m\u00B3"],
+
+    "fluidOunce": ["fl oz"],
+    "gallon": ["gal"],
+
+    "gram": ["g"],
+    "kiloGram": ["kg"],
+    "tonne": ["T"],
+
+    "ounce": ["oz"],    
+    "pound": ["lbs"],
+    "ton": ["T"],
+
+    "second": ["s"],
+    "minute": ["mi"],
+    "hour": ["h", "Hour"],
+    "day": ["d", "Day"],
+    "week": ["w", "Week"],
+    "month": ["mo", "Month"],
+    "year": ["y", "Year"],
+
+    "milliWatt": ["mW"],
+    "watt": ["W"],
+    "kiloWatt": ["kW"],
+    "megaWatt": ["MW"],
+    "gigaWatt": ["GW"],
+
+    "joulesPerSecond": ["J/s"],
+    "joulesPerMinute": ["J/mi"],
+    "joulesPerHour": ["J/t"],
+    
+    "litersPerSecond": ["L/s"],
+    "litersPerMinute": ["L/mi"],
+    "litersPerHour": ["L/t"],
+
+    "cubicMetersPerSecond": ["m\u00B3/s"],
+    "cubicMetersPerMinute": ["m\u00B3/mi"],
+    "cubicMetersPerHour": ["m\u00B3/t"],
+
+    "fluidOuncesPerSecond": ["fl oz/s"],
+    "fluidOuncesPerMinute": ["fl oz/mi"],
+    "fluidOuncesPerHour": ["fl oz/t"],
+    
+    "gallonsPerSecond": ["gal/s"],
+    "gallonsPerMinute": ["gal/mi"],
+    "gallonsPerHour": ["gal/t"],
+
+    "gramsPerSecond": ["g/s"],
+    "gramsPerMinute": ["g/mi"],
+    "gramsPerHour": ["g/t"],
+    
+    "kiloGramsPerSecond": ["kg/s"],
+    "kiloGramsPerMinute": ["kg/mi"],
+    "kiloGramsPerHour": ["kg/t"],
+    
+    "celcius": ["\u00B0C"],
+    "kelvin": ["K"],
+    "fahrenheit": ["F"],
+    
+    "var": ["var"],
+    "kiloVar": ["kvar"],
+    "megaVar": ["Mvar"],
+    
+    "varHour": ["varh"],
+    "kiloVarHour": ["kvarh"],
+    "megaVarHour": ["Mvarh"],
+    
+    "percentage": ["%"],
+
+    "literCelcius": ["l\u00B7\u2103"],
+    "cubicMeterCelcius": ["m\u00B3\u00B7\u2103"]
+}

package/package.json

@@ -1,29 +1,36 @@
 {
   "name": "@utiliread/primitives",
-  "version": "1.0.0-6",
+  "version": "1.0.0-60",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
+  "sideEffects": false,
   "scripts": {
     "build": "tsc && tsc -p tsconfig.cjs.json",
     "test": "karma start --single-run --browsers ChromeHeadless karma.config.js",
     "watch": "karma start --auto-watch --browsers ChromeDebugging karma.config.js",
+    "chrome": "karma start --auto-watch --browsers Chrome karma.config.js",
     "clean": "rimraf dist"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@types/chai": "^4.2.16",
-    "@types/mocha": "^8.2.2",
+    "@types/chai": "^4.2.18",
+    "@types/luxon": "^2.3.2",
+    "@types/mocha": "^9.0.0",
     "chai": "^4.3.4",
     "karma": "^6.3.2",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-mocha": "^2.0.1",
     "karma-typescript": "^5.5.1",
-    "mocha": "^8.3.2",
+    "luxon": "^2.1.0",
+    "mocha": "^9.1.3",
     "rimraf": "^3.0.2",
     "typescript": "^4.1.5"
+  },
+  "peerDependencies": {
+    "luxon": "^2.1.0"
   }
 }

package/src/aggregate-id.ts

@@ -1,9 +1,9 @@
-export type AggregateId =
-    "instant" |
-    "diff" |
-    "min" |
-    "max" |
-    "avg" |
-    "sum" |
-    "cnt" |
-    "ssq";
+export type AggregateId =
+    "instant" |
+    "diff" |
+    "min" |
+    "max" |
+    "avg" |
+    "sum" |
+    "cnt" |
+    "ssq";

package/src/consumption-type-id.ts

@@ -1,8 +1,8 @@
-export type ConsumptionTypeId =
-    "none" |
-    "heat" |
-    "water" |
-    "cooling" |
-    "electricity" |
-    "infrastructure" |
-    "all";
+export type ConsumptionTypeId =
+    "none" |
+    "heat" |
+    "water" |
+    "cooling" |
+    "electricity" |
+    "infrastructure" |
+    "all";

package/src/index.ts

@@ -1,17 +1,35 @@
-import { ConsumptionTypeId } from "./consumption-type-id";
-import { RegisterId } from "./register-id";
-import { UnitId } from "./unit-id";
+import type { ConsumptionTypeId } from "./consumption-type-id";
+import type { RegisterId } from "./register-id";
+import type { UnitId } from "./unit-id";
 import { RegisterLibrary } from "./register-library";
-import { RegisterDefinition } from "./register-definition";
-import { RegisterConverter } from "./register-converter";
-import { NumberFormatter } from "./number-formatter";
+import type { RegisterDefinition } from "./register-definition";
+import { NumberFormatter, invariantDecimalSeparator, localeDecimalSeparator } from "./number-formatter";
+import { RegisterConvention } from "./register-convention";
+import type { AggregateId } from "./aggregate-id";
+import type { MeasureId } from "./measure-id";
+import { Step, DayOfWeek } from "./step";
+import { TimeOrRule } from "./time-or-rule";
+import { PrecisionNumber } from "./precision-number";
+import "./repository"; // We need this to get the Repository namespace exported
+import { Repository } from "./repository";
+import type { Optional } from "./optional";
 
 export {
+    AggregateId,
     ConsumptionTypeId,
-    RegisterId,
+    DayOfWeek,
+    MeasureId,
+    NumberFormatter,
+    PrecisionNumber,
+    RegisterConvention,
     RegisterDefinition,
-    UnitId,
+    RegisterId,
     RegisterLibrary,
-    RegisterConverter,
-    NumberFormatter,
-};
+    Repository,
+    Step,
+    TimeOrRule,
+    UnitId,
+    invariantDecimalSeparator,
+    localeDecimalSeparator,
+    Optional,
+};

package/src/measure-id.ts

@@ -0,0 +1,14 @@
+export type MeasureId =
+    "none" |
+    "duration" |
+    "energy" |
+    "humidity" |
+    "mass" |
+    "massFlow" |
+    "power" |
+    "reactiveEnergy" |
+    "reactivePower" |
+    "temperature" |
+    "time" |
+    "volume" |
+    "volumeFlow";

package/src/number-formatter.spec.ts

@@ -0,0 +1,99 @@
+import { expect } from 'chai';
+import { NumberFormatter, Parts, localeDecimalSeparator, invariantDecimalSeparator } from './number-formatter';
+
+describe("toParts and toPrecision", () => {
+    it("should format correctly", () => {
+        const data: [number, number, Parts][] = [
+            [0, 0, { invariantPrecisionString: "0", invariantCoefficientString: "0", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [0.0, 1, { invariantPrecisionString: "0.0", invariantCoefficientString: "0.0", exponent: 0, noOfCoefficientDecimals: 1 }],
+            [77.1274, 1, { invariantPrecisionString: "8e+1", invariantCoefficientString: "8", exponent: 1, noOfCoefficientDecimals: 0 }],
+            [77.1274, 2, { invariantPrecisionString: "77", invariantCoefficientString: "77", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [77.1274, 4, { invariantPrecisionString: "77.13", invariantCoefficientString: "77.13", exponent: 0, noOfCoefficientDecimals: 2 }],
+            [77.1274, 5, { invariantPrecisionString: "77.127", invariantCoefficientString: "77.127", exponent: 0, noOfCoefficientDecimals: 3 }],
+            [77.1274, 6, { invariantPrecisionString: "77.1274", invariantCoefficientString: "77.1274", exponent: 0, noOfCoefficientDecimals: 4 }],
+            [77.1274, 7, { invariantPrecisionString: "77.12740", invariantCoefficientString: "77.12740", exponent: 0, noOfCoefficientDecimals: 5 }],
+            [77.1274, 15, { invariantPrecisionString: "77.1274000000000", invariantCoefficientString: "77.1274000000000", exponent: 0, noOfCoefficientDecimals: 13 }],
+            [77.1274, 16, { invariantPrecisionString: "77.12739999999999", invariantCoefficientString: "77.12739999999999", exponent: 0, noOfCoefficientDecimals: 14 }],
+            [77.1274, 17, { invariantPrecisionString: "77.127399999999994", invariantCoefficientString: "77.127399999999994", exponent: 0, noOfCoefficientDecimals: 15 }],
+            [77.1274, 18, { invariantPrecisionString: "77.1273999999999944", invariantCoefficientString: "77.1273999999999944", exponent: 0, noOfCoefficientDecimals: 16 }],
+            [77.1274, 19, { invariantPrecisionString: "77.12739999999999441", invariantCoefficientString: "77.12739999999999441", exponent: 0, noOfCoefficientDecimals: 17 }],
+            [77.1274, 20, { invariantPrecisionString: "77.127399999999994407", invariantCoefficientString: "77.127399999999994407", exponent: 0, noOfCoefficientDecimals: 18 }],
+            [77.1274, 21, { invariantPrecisionString: "77.1273999999999944066", invariantCoefficientString: "77.1273999999999944066", exponent: 0, noOfCoefficientDecimals: 19 }],
+            [0.00000123, 2, { invariantPrecisionString: "0.0000012", invariantCoefficientString: "0.0000012", exponent: 0, noOfCoefficientDecimals: 7 }],
+            [0.000000123, 2, { invariantPrecisionString: "1.2e-7", invariantCoefficientString: "1.2", exponent: -7, noOfCoefficientDecimals: 1 }],
+            [0.00000123, 21, { invariantPrecisionString: "0.00000123000000000000008198", invariantCoefficientString: "0.00000123000000000000008198", exponent: 0, noOfCoefficientDecimals: 26 }],
+            [123456, 3, { invariantPrecisionString: "1.23e+5", invariantCoefficientString: "1.23", exponent: 5, noOfCoefficientDecimals: 2 }],
+            [Number.MAX_VALUE, 3, { invariantPrecisionString: "1.80e+308", invariantCoefficientString: "1.80", exponent: 308, noOfCoefficientDecimals: 2 }],
+            [123456, 15, { invariantPrecisionString: "123456.000000000", invariantCoefficientString: "123456.000000000", exponent: 0, noOfCoefficientDecimals: 9 }],
+            [0, 5, { invariantPrecisionString: "0.00000", invariantCoefficientString: "0.00000", exponent: 0, noOfCoefficientDecimals: 5 }],
+            [0.000001, 1, { invariantPrecisionString: "0.000001", invariantCoefficientString: "0.000001", exponent: 0, noOfCoefficientDecimals: 6 }],
+            [0.000001, 10, { invariantPrecisionString: "0.000001000000000", invariantCoefficientString: "0.000001000000000", exponent: 0, noOfCoefficientDecimals: 15 }],
+            [0.0000001, 10, { invariantPrecisionString: "1.000000000e-7", invariantCoefficientString: "1.000000000", exponent: -7, noOfCoefficientDecimals: 9 }],
+            [0.00000000001, 1, { invariantPrecisionString: "1e-11", invariantCoefficientString: "1", exponent: -11, noOfCoefficientDecimals: 0 }],
+            [0.00000000001, 2, { invariantPrecisionString: "1.0e-11", invariantCoefficientString: "1.0", exponent: -11, noOfCoefficientDecimals: 1 }],
+            [55, 2, { invariantPrecisionString: "55", invariantCoefficientString: "55", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [55, 1, { invariantPrecisionString: "6e+1", invariantCoefficientString: "6", exponent: 1, noOfCoefficientDecimals: 0 }],
+            [-55, 2, { invariantPrecisionString: "-55", invariantCoefficientString: "-55", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [-55, 1, { invariantPrecisionString: "-6e+1", invariantCoefficientString: "-6", exponent: 1, noOfCoefficientDecimals: 0 }],
+            [9.59, 1, { invariantPrecisionString: "1e+1", invariantCoefficientString: "1", exponent: 1, noOfCoefficientDecimals: 0 }],
+            [9.59, 2, { invariantPrecisionString: "10", invariantCoefficientString: "10", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [9.95, 2, { invariantPrecisionString: "10", invariantCoefficientString: "10", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [9.96, 2, { invariantPrecisionString: "10", invariantCoefficientString: "10", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [-555555555555555555555, 1, { invariantPrecisionString: "-6e+20", invariantCoefficientString: "-6", exponent: 20, noOfCoefficientDecimals: 0 }],
+            [-5555555555555555555555, 1, { invariantPrecisionString: "-6e+21", invariantCoefficientString: "-6", exponent: 21, noOfCoefficientDecimals: 0 }],
+            [18014398509482012, 21, { invariantPrecisionString: "18014398509482012.0000", invariantCoefficientString: "18014398509482012.0000", exponent: 0, noOfCoefficientDecimals: 4 }],
+            [180143985094820121234, 21, { invariantPrecisionString: "180143985094820134912", invariantCoefficientString: "180143985094820134912", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [0.1, 21, { invariantPrecisionString: "0.100000000000000005551", invariantCoefficientString: "0.100000000000000005551", exponent: 0, noOfCoefficientDecimals: 21 }],
+            [Number.EPSILON, 2, { invariantPrecisionString: "2.2e-16", invariantCoefficientString: "2.2", exponent: -16, noOfCoefficientDecimals: 1 }],
+            [Number.EPSILON, 21, { invariantPrecisionString: "2.22044604925031308085e-16", invariantCoefficientString: "2.22044604925031308085", exponent: -16, noOfCoefficientDecimals: 20 }],
+            [Number.NaN, 3, { invariantPrecisionString: "NaN", invariantCoefficientString: "NaN", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [Number.POSITIVE_INFINITY, 3, { invariantPrecisionString: "Infinity", invariantCoefficientString: "Infinity", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [Number.NEGATIVE_INFINITY, 3, { invariantPrecisionString: "-Infinity", invariantCoefficientString: "-Infinity", exponent: 0, noOfCoefficientDecimals: 0 }],
+            [164735280, 7, { invariantPrecisionString: "1.647353e+8", invariantCoefficientString: "1.647353", exponent: 8, noOfCoefficientDecimals: 6 }],
+        ];
+
+        for (const [value, precision, expectedParts] of data) {
+            expect(NumberFormatter.toPrecision(value, precision)).to.equal(expectedParts.invariantPrecisionString);
+
+            const localePrecisionString = expectedParts.invariantPrecisionString.replace(invariantDecimalSeparator, localeDecimalSeparator);
+            expect(NumberFormatter.toLocalePrecision(value, precision)).to.equal(localePrecisionString);
+
+            const parts = NumberFormatter.getParts(value, precision);
+            expect(parts.invariantPrecisionString).to.equal(expectedParts.invariantPrecisionString);
+            expect(parts.invariantCoefficientString).to.equal(expectedParts.invariantCoefficientString);
+            expect(parts.exponent).to.equal(expectedParts.exponent);
+            expect(parts.noOfCoefficientDecimals).to.equal(expectedParts.noOfCoefficientDecimals);
+        }
+    })
+})
+
+describe("toFixed", () => {
+    it("should format correctly", () => {
+        const data: [number, number, string][] = [
+            [0, 0, "0"],
+            [0.0, 1, "0.0"],
+            [10, 1, "10"],
+            [10, 2, "10"],
+            [10, 3, "10.0"],
+            [10, 4, "10.00"],
+            [10.2, 1, "10"],
+            [10.2, 2, "10"],
+            [10.2, 3, "10.2"],
+            [10.2, 4, "10.20"],
+            [217887000000, 6, "217887000000"],
+        ];
+
+        for (const [value, precision, invariantExpected] of data) {
+            expect(NumberFormatter.toFixed(value, precision)).to.equal(invariantExpected);
+
+            const localeExpected = invariantExpected.replace(invariantDecimalSeparator, localeDecimalSeparator);
+            expect(NumberFormatter.toLocaleFixed(value, precision)).to.equal(localeExpected);
+        }
+    })
+})
+
+describe("toLocaleFixed", () => {
+    it("should format correctly", () => {
+        expect(NumberFormatter.toLocaleFixed(400, 2)).to.equal("400");
+    })
+});

package/src/number-formatter.ts

@@ -1,52 +1,88 @@
-export const invariantDecimalSeparator = (0.1).toString()[1];
-export const localeDecimalSeparator = (0.1).toLocaleString()[1];
-
-class Formatter {
-    public toLocalePrecision(value: number, precision: number) {
-        const absValue = Math.abs(value);
-        if (absValue < 1) {
-            return toPrecision(value, precision);
-        }
-
-        const noOfIntegerDigits = Math.round(absValue).toString().length;
-        return precision >= noOfIntegerDigits
-            ? toFixed(value, precision - noOfIntegerDigits)
-            : toPrecision(value, precision);
-    }
-
-    public toLocaleFixed(value: number, precision: number) {
-        const formatted = this.toLocalePrecision(value, precision);
-        const match = /(.*)e\+(\d)$/.exec(formatted);
-        if (match) {
-            let number = match[1];
-            let exponent = parseInt(match[2]);
-            const decimalSeparatorIndex = number.indexOf(localeDecimalSeparator);
-            if (decimalSeparatorIndex === -1) {
-                return `${number}${"0".repeat(exponent)}`;
-            }
-            else if (decimalSeparatorIndex >= 0) {
-                const noOfDecimals = number.length - decimalSeparatorIndex - 1;
-
-                if (noOfDecimals < exponent) {
-                    number = number.replace(localeDecimalSeparator, "");
-                    exponent -= noOfDecimals;
-
-                    return `${number}${"0".repeat(exponent)}`;
-                }
-            }
-        }
-        return formatted;
-    }
-}
-
-function toFixed(value: number, fractionDigits: number) {
-    const formatted = value.toFixed(fractionDigits);
-    return formatted.replace(invariantDecimalSeparator, localeDecimalSeparator);
-}
-
-function toPrecision(value: number, precision: number) {
-    const formatted = value.toPrecision(precision);
-    return formatted.replace(invariantDecimalSeparator, localeDecimalSeparator);
-}
-
-export const NumberFormatter = new Formatter();
+export const invariantDecimalSeparator = (0.1).toString()[1];
+export const localeDecimalSeparator = (0.1).toLocaleString()[1];
+
+export interface Parts {
+    invariantPrecisionString: string;
+    invariantCoefficientString: string;
+    exponent: number;
+    noOfCoefficientDecimals: number;
+}
+
+class Formatter {
+    public toPrecision(value: number, precision: number) {
+        if (value === 0) {
+            // (0).toPrecision(1) == "0"
+            // (0).toPrecision(2) == "0.0"
+            // (0).toPrecision(3) == "0.00"
+            // However, we want:
+            // Formatter.toPrecision(0, 0) == "0"
+            // Formatter.toPrecision(0, 1) == "0.0"
+            // Formatter.toPrecision(0, 2) == "0.00"
+            return value.toPrecision(precision + 1);
+        }
+        const absValue = Math.abs(value);
+        if (absValue < 1) {
+            return value.toPrecision(precision);
+        }
+
+        const noOfIntegerDigits = Math.round(absValue).toString().length;
+        return precision >= noOfIntegerDigits
+            ? value.toFixed(precision - noOfIntegerDigits)
+            : value.toPrecision(precision);
+    }
+
+    public toLocalePrecision(value: number, precision: number) {
+        return this.toPrecision(value, precision)
+            .replace(invariantDecimalSeparator, localeDecimalSeparator);
+    }
+
+    public toFixed(value: number, precision: number) {
+        const parts = this.getParts(value, precision);
+        if (parts.noOfCoefficientDecimals < parts.exponent) {
+            const number = parts.invariantCoefficientString.replace(invariantDecimalSeparator, "");
+            const zeros = parts.exponent - parts.noOfCoefficientDecimals;
+            return `${number}${"0".repeat(zeros)}`;
+        }
+        else {
+            return parts.invariantPrecisionString;
+        }
+    }
+
+    public toLocaleFixed(value: number, precision: number) {
+        return this.toFixed(value, precision)
+            .replace(invariantDecimalSeparator, localeDecimalSeparator);
+    }
+
+    public getParts(value: number, precision: number): Parts {
+        const precisionString = this.toPrecision(value, precision);
+        if (precisionString.indexOf("e") >= 0) {
+            const match = /(.*)e([\+-]\d+)$/.exec(precisionString)!;
+            const coefficientString = match[1];
+            const exponent = parseInt(match[2]);
+            const decimalSeparatorIndex = coefficientString.indexOf(invariantDecimalSeparator);
+            const noOfCoefficientDecimals = decimalSeparatorIndex >= 0
+                ? coefficientString.length - decimalSeparatorIndex - 1
+                : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: coefficientString,
+                exponent,
+                noOfCoefficientDecimals,
+            };
+        }
+        else {
+            const decimalSeparatorIndex = precisionString.indexOf(invariantDecimalSeparator);
+            const noOfCoefficientDecimals = decimalSeparatorIndex >= 0
+                ? precisionString.length - decimalSeparatorIndex - 1
+                : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: precisionString,
+                exponent: 0,
+                noOfCoefficientDecimals,
+            };
+        }
+    }
+}
+
+export const NumberFormatter = new Formatter();

package/src/optional.ts

@@ -0,0 +1 @@
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

package/src/precision-number.spec.ts

@@ -0,0 +1,28 @@
+import { expect } from "chai";
+import { PrecisionNumber } from "./precision-number";
+
+describe("precision-number", () => {
+    it("should not parse ''", () => {
+        const number = PrecisionNumber.parse("");
+        expect(Number.isNaN(number.value)).to.equal(true);
+        expect(number.precision).to.equal(0);
+    });
+
+    it("should parse '1'", () => {
+        const number = PrecisionNumber.parse("1");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '1.'", () => {
+        const number = PrecisionNumber.parse("1.");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse '1.0'", () => {
+        const number = PrecisionNumber.parse("1.0");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(2);
+    });
+});

package/src/precision-number.ts

@@ -0,0 +1,36 @@
+import { invariantDecimalSeparator } from ".";
+import { localeDecimalSeparator, NumberFormatter } from "./number-formatter";
+
+export class PrecisionNumber {
+    constructor(public value: number, public precision: number) {
+    }
+
+    static parse(input: string) {
+        let normalized = input.trim().replace(",", ".").replace(localeDecimalSeparator, invariantDecimalSeparator);
+        if (normalized.endsWith(invariantDecimalSeparator)) {
+            normalized += "0";
+        }
+        const precision = normalized.replace(".", "").replace("+", "").replace("-", "").length;
+        return new PrecisionNumber(parseFloat(normalized), precision);
+    }
+
+    toString() {
+        return this.value.toString();
+    }
+
+    toFixed() {
+        return NumberFormatter.toFixed(this.value, this.precision);
+    }
+
+    toPrecision() {
+        return NumberFormatter.toPrecision(this.value, this.precision);
+    }
+
+    toLocaleFixed() {
+        return NumberFormatter.toLocaleFixed(this.value, this.precision);
+    }
+
+    toLocalePrecision() {
+        return NumberFormatter.toLocalePrecision(this.value, this.precision);
+    }
+}

package/src/register-convention.spec.ts

@@ -0,0 +1,43 @@
+import { expect } from "chai";
+import { RegisterConvention } from "./register-convention";
+
+describe("getAggregate", () => {
+    it("instant register is instant", () => {
+        const result = RegisterConvention.getAggregate("flowTemperature");
+        expect(result).to.equal("instant");
+    });
+
+    it("avg register is avg", () => {
+        const result = RegisterConvention.getAggregate("avgFlowTemperature");
+        expect(result).to.equal("avg");
+    });
+});
+
+describe("toInstant", () => {
+    it("should convert instant", () => {
+        const registerId = RegisterConvention.toInstant("flowTemperature");
+        expect(registerId).to.equal("flowTemperature");
+    });
+
+    it("should convert aggregate", () => {
+        const registerId = RegisterConvention.toInstant("avgFlowTemperature");
+        expect(registerId).to.equal("flowTemperature");
+    });
+});
+
+describe("toAggregate", () => {
+    it("should convert instant to aggregate", () => {
+        const registerId = RegisterConvention.toAggregate("flowTemperature", "avg");
+        expect(registerId).to.equal("avgFlowTemperature");
+    });
+
+    it("should convert aggregate to same aggregate", () => {
+        const registerId = RegisterConvention.toAggregate("avgFlowTemperature", "avg");
+        expect(registerId).to.equal("avgFlowTemperature");
+    });
+
+    it("should convert aggregate to other aggregate", () => {
+        const registerId = RegisterConvention.toAggregate("avgFlowTemperature", "min");
+        expect(registerId).to.equal("minFlowTemperature");
+    });
+});

package/src/register-convention.ts

@@ -0,0 +1,61 @@
+import { RegisterDefinition } from ".";
+import { AggregateId } from "./aggregate-id";
+import { RegisterId } from "./register-id";
+import { getRegisterId } from "./register-utils";
+
+export const aggregatePrefixes: { [aggregateId in AggregateId]: string } = {
+    instant: "",
+    diff: "diff",
+    min: "min",
+    max: "max",
+    avg: "avg",
+    sum: "sum",
+    cnt: "cnt",
+    ssq: "ssq",
+};
+
+class Convention {
+    public getAggregate(register: RegisterId | RegisterDefinition) {
+        const registerId = getRegisterId(register);
+        // Brute force all prefixes - if none of them, then it must be instant.
+        for (const aggregateString of Object.keys(aggregatePrefixes)) {
+            const aggregate = <AggregateId>aggregateString;
+            const prefix = aggregatePrefixes[aggregate];
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                // Not instant - it was any of the others.
+                return aggregate;
+            }
+        }
+        return "instant";
+    }
+
+    toInstant(register: RegisterId | RegisterDefinition) {
+        const registerId = getRegisterId(register);
+        for (const prefix of Object.values(aggregatePrefixes)) {
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                const tail = registerId.substr(prefix.length);
+                return <RegisterId>(tail[0].toLowerCase() + tail.substr(1));
+            }
+        }
+        return registerId;
+    }
+
+    toAggregate(register: RegisterId | RegisterDefinition, aggregate: AggregateId) {
+        const instantRegisterId = this.toInstant(register);
+        if (aggregate === "instant") {
+            return instantRegisterId;
+        }
+        const prefix = aggregatePrefixes[aggregate];
+        return <RegisterId>(prefix + instantRegisterId[0].toUpperCase() + instantRegisterId.substr(1));
+    }
+}
+
+export function isPrefix(registerId: RegisterId, prefix: string) {
+    return registerId.startsWith(prefix) && isUppercase(registerId[prefix.length]);
+}
+
+function isUppercase(input: string) {
+    return input.toUpperCase() === input;
+}
+
+export const RegisterConvention = new Convention();