Add singular forms for units

Models/Denomination.ts

@@ -1,13 +1,19 @@
 import {Translation} from "../UI/i18n/Translation";
 import {ApplicableUnitJson} from "./ThemeConfig/Json/UnitConfigJson";
 import Translations from "../UI/i18n/Translations";
+import {UIEventSource} from "../Logic/UIEventSource";
+import BaseUIElement from "../UI/BaseUIElement";
+import Toggle from "../UI/Input/Toggle";
 
 export class Denomination {
     public readonly canonical: string;
-    readonly default: boolean;
-    readonly prefix: boolean;
+    public readonly _canonicalSingular: string;
+    public readonly default: boolean;
+    public readonly prefix: boolean;
     public readonly alternativeDenominations: string [];
     private readonly _human: Translation;
+    private readonly _humanSingular?: Translation;
+
 
     constructor(json: ApplicableUnitJson, context: string) {
         context = `${context}.unit(${json.canonicalDenomination})`
@@ -15,6 +21,8 @@ export class Denomination {
         if (this.canonical === undefined) {
             throw `${context}: this unit has no decent canonical value defined`
         }
+        this._canonicalSingular = json.canonicalDenominationSingular?.trim()
+
 
         json.alternativeDenomination.forEach((v, i) => {
             if (((v?.trim() ?? "") === "")) {
@@ -27,6 +35,7 @@ export class Denomination {
         this.default = json.default ?? false;
 
         this._human = Translations.T(json.human, context + "human")
+        this._humanSingular = Translations.T(json.humanSingular, context + "humanSingular")
 
         this.prefix = json.prefix ?? false;
 
@@ -35,7 +44,22 @@ export class Denomination {
     get human(): Translation {
         return this._human.Clone()
     }
-
+   
+    get humanSingular(): Translation {
+        return (this._humanSingular ?? this._human).Clone()
+    }
+    
+    getToggledHuman(isSingular: UIEventSource<boolean>): BaseUIElement{
+        if(this._humanSingular === undefined){
+            return this.human
+        }
+        return new Toggle(
+            this.humanSingular,
+            this.human,
+            isSingular
+        )
+    }
+    
     public canonicalValue(value: string, actAsDefault?: boolean) {
         if (value === undefined) {
             return undefined;
@@ -44,9 +68,12 @@ export class Denomination {
         if (stripped === null) {
             return null;
         }
-        return (stripped + " " + this.canonical.trim()).trim();
+        if(stripped === "1" && this._canonicalSingular !== undefined){
+            return "1 "+this._canonicalSingular
+        }
+        return stripped + " " + this.canonical;
     }
-
+    
     /**
      * Returns the core value (without unit) if:
      * - the value ends with the canonical or an alternative value (or begins with if prefix is set)
@@ -61,26 +88,36 @@ export class Denomination {
         }
 
         value = value.toLowerCase()
-        if (this.prefix) {
-            if (value.startsWith(this.canonical) && this.canonical !== "") {
-                return value.substring(this.canonical.length).trim();
-            }
-            for (const alternativeValue of this.alternativeDenominations) {
-                if (value.startsWith(alternativeValue)) {
-                    return value.substring(alternativeValue.length).trim();
-                }
-            }
-        } else {
-            if (value.endsWith(this.canonical.toLowerCase()) && this.canonical !== "") {
-                return value.substring(0, value.length - this.canonical.length).trim();
-            }
-            for (const alternativeValue of this.alternativeDenominations) {
-                if (value.endsWith(alternativeValue.toLowerCase())) {
-                    return value.substring(0, value.length - alternativeValue.length).trim();
-                }
+        const self = this;
+        function startsWith(key){
+            if(self.prefix){
+                return value.startsWith(key)
+            }else{
+                return value.endsWith(key)
+            }
+        }
+        
+        function substr(key){
+            if(self.prefix){
+                return value.substr(key.length).trim()
+            }else{
+                return value.substring(0, value.length - key.length).trim()
+            }
+        }
+        
+        if(this.canonical !== "" && startsWith(this.canonical.toLowerCase())){
+            return substr(this.canonical)
+        } 
+        
+        if(this._canonicalSingular !== undefined && this._canonicalSingular !== "" && startsWith(this._canonicalSingular)){
+            return substr(this._canonicalSingular)
+        }
+        
+        for (const alternativeValue of this.alternativeDenominations) {
+            if (startsWith(alternativeValue)) {
+                return substr(alternativeValue);
             }
         }
-
 
         if (this.default || actAsDefault) {
             const parsed = Number(value.trim())