@lion/ui 0.20.0 → 0.21.0

package/custom-elements.json

@@ -2212,36 +2212,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "exports/define-helpers/sb-action-logger.js",
-      "declarations": [],
-      "exports": [
-        {
-          "kind": "custom-element-definition",
-          "name": "sb-action-logger",
-          "declaration": {
-            "name": "SbActionLogger",
-            "module": "/exports/helpers.js"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "exports/define-helpers/sb-locale-switcher.js",
-      "declarations": [],
-      "exports": [
-        {
-          "kind": "custom-element-definition",
-          "name": "sb-locale-switcher",
-          "declaration": {
-            "name": "SbLocaleSwitcher",
-            "module": "/exports/helpers.js"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "exports/define/lion-accordion.js",
@@ -2947,6 +2917,36 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "exports/define-helpers/sb-action-logger.js",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "custom-element-definition",
+          "name": "sb-action-logger",
+          "declaration": {
+            "name": "SbActionLogger",
+            "module": "/exports/helpers.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "exports/define-helpers/sb-locale-switcher.js",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "custom-element-definition",
+          "name": "sb-locale-switcher",
+          "declaration": {
+            "name": "SbLocaleSwitcher",
+            "module": "/exports/helpers.js"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "components/accordion/src/LionAccordion.js",
@@ -8322,7 +8322,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -9002,7 +9002,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -9793,6 +9793,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -11777,7 +11787,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -12434,7 +12444,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -13210,6 +13220,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -24298,7 +24318,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -24955,7 +24975,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -25731,6 +25751,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -26982,7 +27012,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -27639,7 +27669,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -28415,6 +28445,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -30272,7 +30312,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -30929,7 +30969,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -31705,6 +31745,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -35718,7 +35768,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -36375,7 +36425,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -37151,6 +37201,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -39258,7 +39318,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators."
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators."
             },
             {
               "kind": "field",
@@ -39273,6 +39333,11 @@
                 }
               ]
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "preprocessor",
@@ -39292,7 +39357,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -44123,7 +44188,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -44717,7 +44782,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -45429,6 +45494,16 @@
                 "module": "components/form-core/src/FormControlMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -47376,7 +47451,16 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -47401,7 +47485,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -61432,7 +61516,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -61455,6 +61539,15 @@
                 "module": "components/form-core/src/FormatMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              }
+            },
             {
               "kind": "method",
               "name": "preprocessor",
@@ -61474,7 +61567,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -69860,7 +69953,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -70487,7 +70580,8 @@
               "attribute": "modelValue",
               "type": {
                 "text": "object"
-              }
+              },
+              "description": "For a FormControl to function properly, its modelValue, serializedValue and  viewValue/formattedValue\nshould always translate in two directions. This is expected by `_callParser` method. It guards for empty\nviewValues. As the viewValue (`.value`) only concerns the amount part and not the currency part in\nInputAmountDropdown, this contract is broken.\nBelow, we compensate for this."
             },
             {
               "kind": "field",
@@ -70617,7 +70711,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -71501,6 +71595,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -72397,6 +72501,16 @@
                 "module": "components/form-core/src/LionField.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "__modelValue",
+              "description": "The internal modelValue is a combination of the amount and the currency code. The amount is a number, the currency code is a string.",
+              "privacy": "private",
+              "type": {
+                "text": "AmountDropdownModelValue"
+              },
+              "default": "{ currency: this.currency, amount: '' }"
+            },
             {
               "kind": "method",
               "name": "__onBlur",
@@ -72819,17 +72933,6 @@
             }
           ],
           "attributes": [
-            {
-              "name": "modelValue",
-              "fieldName": "modelValue",
-              "type": {
-                "text": "object"
-              },
-              "inheritedFrom": {
-                "name": "LionInputAmount",
-                "module": "components/input-amount/src/LionInputAmount.js"
-              }
-            },
             {
               "name": "preferredCurrencies",
               "type": {
@@ -72869,6 +72972,14 @@
                 "module": "components/input-amount/src/LionInputAmount.js"
               }
             },
+            {
+              "name": "modelValue",
+              "fieldName": "modelValue",
+              "inheritedFrom": {
+                "name": "LionInputAmount",
+                "module": "components/input-amount/src/LionInputAmount.js"
+              }
+            },
             {
               "name": "autocomplete",
               "type": {
@@ -73351,7 +73462,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -74073,7 +74184,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -74892,6 +75003,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -76734,7 +76855,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -77428,7 +77549,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -78235,6 +78356,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -80021,7 +80152,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -80740,7 +80871,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -81673,6 +81804,16 @@
               "description": "Subclassers can replace this with their custom extension invoker,\nlike `<my-button><calendar-icon></calendar-icon></my-button>`",
               "privacy": "protected"
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -83530,7 +83671,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -84230,7 +84371,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -85038,6 +85179,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -86695,7 +86846,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -87432,7 +87583,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -88306,6 +88457,16 @@
               "privacy": "protected",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -91413,7 +91574,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -92115,7 +92276,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -92923,6 +93084,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -95590,7 +95761,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -96176,6 +96347,16 @@
               "attribute": "max",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "maxLabel",
+              "privacy": "public",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "attribute": "max-label"
+            },
             {
               "kind": "field",
               "name": "min",
@@ -96187,6 +96368,16 @@
               "attribute": "min",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "minLabel",
+              "privacy": "public",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "attribute": "min-label"
+            },
             {
               "kind": "field",
               "name": "modelValue",
@@ -96315,7 +96506,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -97168,6 +97359,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -97649,6 +97850,18 @@
                 "module": "components/form-core/src/LionField.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_valueDisplay",
+              "description": "Get the display info for the current value",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "{ text: string, showUnit: boolean }"
+                }
+              },
+              "readonly": true
+            },
             {
               "kind": "field",
               "name": "_visibleMessagesAmount",
@@ -98367,6 +98580,22 @@
               "default": "false",
               "fieldName": "noMinMaxLabels"
             },
+            {
+              "name": "min-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "fieldName": "minLabel"
+            },
+            {
+              "name": "max-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "fieldName": "maxLabel"
+            },
             {
               "name": "autocomplete",
               "type": {
@@ -98907,7 +99136,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -99635,7 +99864,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -100555,6 +100784,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -102403,7 +102642,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -103178,7 +103417,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue: string; caretIndex: number; } | undefined"
@@ -104034,6 +104273,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -106028,7 +106277,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -106779,7 +107028,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue: string; caretIndex: number; } | undefined"
@@ -107597,6 +107846,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -109780,7 +110039,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -110476,7 +110735,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -111280,6 +111539,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -119385,7 +119654,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "FormatMixin",
                 "module": "components/form-core/src/FormatMixin.js"
@@ -119663,7 +119932,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -119862,6 +120131,16 @@
                 "module": "components/form-core/src/FormatMixin.js"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "FormatMixin",
+                "module": "components/form-core/src/FormatMixin.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -127837,7 +128116,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -128565,7 +128844,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -129390,6 +129669,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -135111,7 +135400,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -135789,7 +136078,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -136559,6 +136848,16 @@
                 }
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -138526,7 +138825,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -139224,7 +139523,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -140010,6 +140309,16 @@
                 "text": "LionSwitchButton"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",
@@ -142354,7 +142663,7 @@
                 "text": "object"
               },
               "default": "{ didFormatterOutputSyncToView: false, didFormatterRun: false, }",
-              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the curent interpretation of separators.",
+              "description": "During format/parse, we sometimes need to know how the current viewValue the user\ninteracts with \"came to be\". Was it already formatted before for instance?\nIf so, in case of an amount input, we might want to stick to the current interpretation of separators.",
               "inheritedFrom": {
                 "name": "LionField",
                 "module": "components/form-core/src/LionField.js"
@@ -143060,7 +143369,7 @@
                   }
                 }
               ],
-              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessro that smartly\nupdates the viewValue and caret position for best UX.",
+              "description": "Preprocessors could be considered 'live formatters'. Their result is shown to the user\non keyup instead of after blurring the field. The biggest difference between preprocessors\nand formatters is their moment of execution: preprocessors are run before modelValue is\ncomputed (and work based on view value), whereas formatters are run after the parser (and\nare based on modelValue)\nAutomatically formats code while typing. It depends on a preprocessor that smartly\nupdates the viewValue and caret position for best UX.",
               "return": {
                 "type": {
                   "text": "{ viewValue:string; caretIndex:number; }|string|undefined"
@@ -143891,6 +144200,16 @@
                 "text": "HTMLInputElement | HTMLTextAreaElement"
               }
             },
+            {
+              "kind": "field",
+              "name": "_isEditingTextField",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LionField",
+                "module": "components/form-core/src/LionField.js"
+              },
+              "privacy": "protected"
+            },
             {
               "kind": "method",
               "name": "_isEmpty",