@itwin/core-quantity 4.0.0-dev.48 → 4.0.0-dev.51

package/lib/esm/Formatter/FormatEnums.js

@@ -1,303 +1,303 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Quantity
- */
-import { QuantityError, QuantityStatus } from "../Exception";
-/** The regular expression to parse [format strings]($docs/bis/ec/kindofquantity.md#format-string)
- * provided in serialized formats as well as the full name of an [[OverrideFormat]].
- *
- * `formatName(precision)[unitName|unitLabel][unitName|unitLabel][unitName|unitLabel][unitName|unitLabel]`
- *
- * Explanation of the regex:
- * - ([\w.:]+)
- *   - Grabs the format full name
- * - (\(([^\)]+)\))?
- *   - Grabs the precision part with and without the `()`.
- *   - The parentheses are needed to validate the entire string.  (TODO: Need to check if this is true)
- * - (\[([^\|\]]+)([\|])?([^\]]+)?\])?
- *   - 4 of these make up the rest of the regex, none of them are required so each end in `?`
- *   - Grabs the unit name and label including the `[]`
- *   - Grabs the unit name, `|` and label separately
- * @internal
- */
-export const formatStringRgx = /([\w.:]+)(\(([^\)]+)\))?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?/;
-/** @internal */
-export function* getItemNamesFromFormatString(formatString) {
-    const match = formatString.split(formatStringRgx);
-    yield match[1]; // the Format Name
-    let index = 4;
-    while (index < match.length - 1) { // index 0 and 21 are empty strings
-        if (match[index] !== undefined)
-            yield match[index + 1]; // Unit Name
-        else
-            break;
-        index += 4;
-    }
-}
-/** @beta */
-export var FormatTraits;
-(function (FormatTraits) {
-    FormatTraits[FormatTraits["Uninitialized"] = 0] = "Uninitialized";
-    /** Show trailing zeroes to requested precision. */
-    FormatTraits[FormatTraits["TrailZeroes"] = 1] = "TrailZeroes";
-    /** Indicates that the fractional part of the number is required when the fraction is zero */
-    FormatTraits[FormatTraits["KeepSingleZero"] = 2] = "KeepSingleZero";
-    /** Zero magnitude returns blank display value */
-    FormatTraits[FormatTraits["ZeroEmpty"] = 4] = "ZeroEmpty";
-    /** Show decimal point when value to right of decimal is empty */
-    FormatTraits[FormatTraits["KeepDecimalPoint"] = 8] = "KeepDecimalPoint";
-    /** Use the rounding factor. Not yet supported  */
-    FormatTraits[FormatTraits["ApplyRounding"] = 16] = "ApplyRounding";
-    /** Show a dash between whole value and fractional value */
-    FormatTraits[FormatTraits["FractionDash"] = 32] = "FractionDash";
-    /** Append the quantity's unit label */
-    FormatTraits[FormatTraits["ShowUnitLabel"] = 64] = "ShowUnitLabel";
-    /** Prepend unit label. Not yet supported */
-    FormatTraits[FormatTraits["PrependUnitLabel"] = 128] = "PrependUnitLabel";
-    /** show a grouping in each group of 1000. */
-    FormatTraits[FormatTraits["Use1000Separator"] = 256] = "Use1000Separator";
-    /** Indicates that if an exponent value is positive to not include a `+`. By default a sign, `+` or `-`, is always shown. Not yet supported */
-    FormatTraits[FormatTraits["ExponentOnlyNegative"] = 512] = "ExponentOnlyNegative";
-})(FormatTraits || (FormatTraits = {}));
-/** Precision for Fractional formatted value types. Range from Whole (1/1) through 1/256.
- * @beta */
-export var FractionalPrecision;
-(function (FractionalPrecision) {
-    FractionalPrecision[FractionalPrecision["One"] = 1] = "One";
-    FractionalPrecision[FractionalPrecision["Two"] = 2] = "Two";
-    FractionalPrecision[FractionalPrecision["Four"] = 4] = "Four";
-    FractionalPrecision[FractionalPrecision["Eight"] = 8] = "Eight";
-    FractionalPrecision[FractionalPrecision["Sixteen"] = 16] = "Sixteen";
-    FractionalPrecision[FractionalPrecision["ThirtyTwo"] = 32] = "ThirtyTwo";
-    FractionalPrecision[FractionalPrecision["SixtyFour"] = 64] = "SixtyFour";
-    FractionalPrecision[FractionalPrecision["OneHundredTwentyEight"] = 128] = "OneHundredTwentyEight";
-    FractionalPrecision[FractionalPrecision["TwoHundredFiftySix"] = 256] = "TwoHundredFiftySix";
-})(FractionalPrecision || (FractionalPrecision = {}));
-/** Precision for Decimal, Scientific, and Station formatted value types. Range from 1/(10^0) through 1/(10^12).
- * @beta */
-export var DecimalPrecision;
-(function (DecimalPrecision) {
-    DecimalPrecision[DecimalPrecision["Zero"] = 0] = "Zero";
-    DecimalPrecision[DecimalPrecision["One"] = 1] = "One";
-    DecimalPrecision[DecimalPrecision["Two"] = 2] = "Two";
-    DecimalPrecision[DecimalPrecision["Three"] = 3] = "Three";
-    DecimalPrecision[DecimalPrecision["Four"] = 4] = "Four";
-    DecimalPrecision[DecimalPrecision["Five"] = 5] = "Five";
-    DecimalPrecision[DecimalPrecision["Six"] = 6] = "Six";
-    DecimalPrecision[DecimalPrecision["Seven"] = 7] = "Seven";
-    DecimalPrecision[DecimalPrecision["Eight"] = 8] = "Eight";
-    DecimalPrecision[DecimalPrecision["Nine"] = 9] = "Nine";
-    DecimalPrecision[DecimalPrecision["Ten"] = 10] = "Ten";
-    DecimalPrecision[DecimalPrecision["Eleven"] = 11] = "Eleven";
-    DecimalPrecision[DecimalPrecision["Twelve"] = 12] = "Twelve";
-})(DecimalPrecision || (DecimalPrecision = {}));
-/** Supported format types
- *  @beta */
-export var FormatType;
-(function (FormatType) {
-    /** Decimal display (ie 2.125) */
-    FormatType[FormatType["Decimal"] = 0] = "Decimal";
-    /** Fractional display (ie 2-1/8) */
-    FormatType[FormatType["Fractional"] = 1] = "Fractional";
-    /** Scientific Notation (ie 1.04e3) */
-    FormatType[FormatType["Scientific"] = 2] = "Scientific";
-    /** Civil Engineering Stationing (ie 1+00). */
-    FormatType[FormatType["Station"] = 3] = "Station";
-})(FormatType || (FormatType = {}));
-/** required if type is scientific
- * @beta */
-export var ScientificType;
-(function (ScientificType) {
-    /** Non-zero value left of decimal point (ie 1.2345e3) */
-    ScientificType[ScientificType["Normalized"] = 0] = "Normalized";
-    /** Zero value left of decimal point (ie 0.12345e4) */
-    ScientificType[ScientificType["ZeroNormalized"] = 1] = "ZeroNormalized";
-})(ScientificType || (ScientificType = {}));
-/** Determines how the sign of values are displayed
- * @beta */
-export var ShowSignOption;
-(function (ShowSignOption) {
-    /** Never show a sign even if the value is negative. */
-    ShowSignOption[ShowSignOption["NoSign"] = 0] = "NoSign";
-    /** Only show a sign when the value is negative. */
-    ShowSignOption[ShowSignOption["OnlyNegative"] = 1] = "OnlyNegative";
-    /** Always show a sign whether the value is positive or negative. */
-    ShowSignOption[ShowSignOption["SignAlways"] = 2] = "SignAlways";
-    /** Only show a sign when the value is negative but use parentheses instead of a negative sign. For example, -10 is formatted as `(10)`. */
-    ShowSignOption[ShowSignOption["NegativeParentheses"] = 3] = "NegativeParentheses";
-})(ShowSignOption || (ShowSignOption = {}));
-// parse and toString methods
-/**  @beta   */
-export function parseScientificType(scientificType, formatName) {
-    switch (scientificType.toLowerCase()) {
-        case "normalized": return ScientificType.Normalized;
-        case "zeronormalized": return ScientificType.ZeroNormalized;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'scientificType' attribute.`);
-    }
-}
-/**  @beta   */
-export function scientificTypeToString(scientificType) {
-    return (scientificType === ScientificType.Normalized) ? "Normalized" : "ZeroNormalized";
-}
-/** @beta    */
-export function parseShowSignOption(showSignOption, formatName) {
-    switch (showSignOption.toLowerCase()) {
-        case "nosign": return ShowSignOption.NoSign;
-        case "onlynegative": return ShowSignOption.OnlyNegative;
-        case "signalways": return ShowSignOption.SignAlways;
-        case "negativeparentheses": return ShowSignOption.NegativeParentheses;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'showSignOption' attribute.`);
-    }
-}
-/**  @beta  */
-export function showSignOptionToString(showSign) {
-    switch (showSign) {
-        case ShowSignOption.NegativeParentheses: return "NegativeParentheses";
-        case ShowSignOption.NoSign: return "NoSign";
-        case ShowSignOption.OnlyNegative: return "OnlyNegative";
-        case ShowSignOption.SignAlways: return "SignAlways";
-    }
-}
-/**  @beta  */
-export function parseFormatTrait(formatTraitsString, formatName) {
-    switch (formatTraitsString.toLowerCase()) {
-        case "trailzeroes": return FormatTraits.TrailZeroes;
-        case "keepsinglezero": return FormatTraits.KeepSingleZero;
-        case "zeroempty": return FormatTraits.ZeroEmpty;
-        case "keepdecimalpoint": return FormatTraits.KeepDecimalPoint;
-        case "applyrounding": return FormatTraits.ApplyRounding;
-        case "fractiondash": return FormatTraits.FractionDash;
-        case "showunitlabel": return FormatTraits.ShowUnitLabel;
-        case "prependunitlabel": return FormatTraits.PrependUnitLabel;
-        case "use1000separator": return FormatTraits.Use1000Separator;
-        case "exponentonlynegative": return FormatTraits.ExponentOnlyNegative;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'formatTraits' attribute.`);
-    }
-}
-/** @beta */
-export function getTraitString(trait) {
-    switch (trait) {
-        case FormatTraits.TrailZeroes:
-            return "trailZeroes";
-        case FormatTraits.KeepSingleZero:
-            return "keepSingleZero";
-        case FormatTraits.ZeroEmpty:
-            return "zeroEmpty";
-        case FormatTraits.KeepDecimalPoint:
-            return "keepDecimalPoint";
-        case FormatTraits.ApplyRounding:
-            return "applyRounding";
-        case FormatTraits.FractionDash:
-            return "fractionDash";
-        case FormatTraits.ShowUnitLabel:
-            return "showUnitLabel";
-        case FormatTraits.PrependUnitLabel:
-            return "prependUnitLabel";
-        case FormatTraits.Use1000Separator:
-            return "use1000Separator";
-        case FormatTraits.ExponentOnlyNegative:
-        default:
-            return "exponentOnlyNegative";
-    }
-}
-/**  @beta  */
-export function formatTraitsToArray(currentFormatTrait) {
-    const formatTraitsArr = Array();
-    if ((currentFormatTrait & FormatTraits.TrailZeroes) === FormatTraits.TrailZeroes)
-        formatTraitsArr.push("TrailZeroes");
-    if ((currentFormatTrait & FormatTraits.KeepSingleZero) === FormatTraits.KeepSingleZero)
-        formatTraitsArr.push("KeepSingleZero");
-    if ((currentFormatTrait & FormatTraits.ZeroEmpty) === FormatTraits.ZeroEmpty)
-        formatTraitsArr.push("ZeroEmpty");
-    if ((currentFormatTrait & FormatTraits.KeepDecimalPoint) === FormatTraits.KeepDecimalPoint)
-        formatTraitsArr.push("KeepDecimalPoint");
-    if ((currentFormatTrait & FormatTraits.ApplyRounding) === FormatTraits.ApplyRounding)
-        formatTraitsArr.push("ApplyRounding");
-    if ((currentFormatTrait & FormatTraits.FractionDash) === FormatTraits.FractionDash)
-        formatTraitsArr.push("FractionDash");
-    if ((currentFormatTrait & FormatTraits.ShowUnitLabel) === FormatTraits.ShowUnitLabel)
-        formatTraitsArr.push("ShowUnitLabel");
-    if ((currentFormatTrait & FormatTraits.PrependUnitLabel) === FormatTraits.PrependUnitLabel)
-        formatTraitsArr.push("PrependUnitLabel");
-    if ((currentFormatTrait & FormatTraits.Use1000Separator) === FormatTraits.Use1000Separator)
-        formatTraitsArr.push("Use1000Separator");
-    if ((currentFormatTrait & FormatTraits.ExponentOnlyNegative) === FormatTraits.ExponentOnlyNegative)
-        formatTraitsArr.push("ExponentOnlyNegative");
-    return formatTraitsArr;
-}
-/**  @beta    */
-export function parseFormatType(jsonObjType, formatName) {
-    switch (jsonObjType.toLowerCase()) {
-        case "decimal": return FormatType.Decimal;
-        case "scientific": return FormatType.Scientific;
-        case "station": return FormatType.Station;
-        case "fractional": return FormatType.Fractional;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'type' attribute.`);
-    }
-}
-/** @beta    */
-export function formatTypeToString(type) {
-    switch (type) {
-        case FormatType.Decimal: return "Decimal";
-        case FormatType.Scientific: return "Scientific";
-        case FormatType.Station: return "Station";
-        case FormatType.Fractional: return "Fractional";
-    }
-}
-/**  @beta    */
-export function parseDecimalPrecision(jsonObjPrecision, formatName) {
-    switch (jsonObjPrecision) {
-        case 0: return DecimalPrecision.Zero;
-        case 1: return DecimalPrecision.One;
-        case 2: return DecimalPrecision.Two;
-        case 3: return DecimalPrecision.Three;
-        case 4: return DecimalPrecision.Four;
-        case 5: return DecimalPrecision.Five;
-        case 6: return DecimalPrecision.Six;
-        case 7: return DecimalPrecision.Seven;
-        case 8: return DecimalPrecision.Eight;
-        case 9: return DecimalPrecision.Nine;
-        case 10: return DecimalPrecision.Ten;
-        case 11: return DecimalPrecision.Eleven;
-        case 12: return DecimalPrecision.Twelve;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
-    }
-}
-/**  @beta validates the input value, that is typically extracted for persisted JSON data, is a valid FractionalPrecision */
-export function parseFractionalPrecision(jsonObjPrecision, formatName) {
-    switch (jsonObjPrecision) {
-        case 1: return FractionalPrecision.One;
-        case 2: return FractionalPrecision.Two;
-        case 4: return FractionalPrecision.Four;
-        case 8: return FractionalPrecision.Eight;
-        case 16: return FractionalPrecision.Sixteen;
-        case 32: return FractionalPrecision.ThirtyTwo;
-        case 64: return FractionalPrecision.SixtyFour;
-        case 128: return FractionalPrecision.OneHundredTwentyEight;
-        case 256: return FractionalPrecision.TwoHundredFiftySix;
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
-    }
-}
-/** @beta  validates the input value, that is typically extracted for persisted JSON data, is a valid DecimalPrecision or FractionalPrecision. */
-export function parsePrecision(precision, type, formatName) {
-    switch (type) { // type must be decimal, fractional, scientific, or station
-        case FormatType.Decimal:
-        case FormatType.Scientific:
-        case FormatType.Station:
-            return parseDecimalPrecision(precision, formatName);
-        case FormatType.Fractional:
-            return parseFractionalPrecision(precision, formatName);
-        default:
-            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Quantity
+ */
+import { QuantityError, QuantityStatus } from "../Exception";
+/** The regular expression to parse [format strings]($docs/bis/ec/kindofquantity.md#format-string)
+ * provided in serialized formats as well as the full name of an [[OverrideFormat]].
+ *
+ * `formatName(precision)[unitName|unitLabel][unitName|unitLabel][unitName|unitLabel][unitName|unitLabel]`
+ *
+ * Explanation of the regex:
+ * - ([\w.:]+)
+ *   - Grabs the format full name
+ * - (\(([^\)]+)\))?
+ *   - Grabs the precision part with and without the `()`.
+ *   - The parentheses are needed to validate the entire string.  (TODO: Need to check if this is true)
+ * - (\[([^\|\]]+)([\|])?([^\]]+)?\])?
+ *   - 4 of these make up the rest of the regex, none of them are required so each end in `?`
+ *   - Grabs the unit name and label including the `[]`
+ *   - Grabs the unit name, `|` and label separately
+ * @internal
+ */
+export const formatStringRgx = /([\w.:]+)(\(([^\)]+)\))?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?(\[([^\|\]]+)([\|])?([^\]]+)?\])?/;
+/** @internal */
+export function* getItemNamesFromFormatString(formatString) {
+    const match = formatString.split(formatStringRgx);
+    yield match[1]; // the Format Name
+    let index = 4;
+    while (index < match.length - 1) { // index 0 and 21 are empty strings
+        if (match[index] !== undefined)
+            yield match[index + 1]; // Unit Name
+        else
+            break;
+        index += 4;
+    }
+}
+/** @beta */
+export var FormatTraits;
+(function (FormatTraits) {
+    FormatTraits[FormatTraits["Uninitialized"] = 0] = "Uninitialized";
+    /** Show trailing zeroes to requested precision. */
+    FormatTraits[FormatTraits["TrailZeroes"] = 1] = "TrailZeroes";
+    /** Indicates that the fractional part of the number is required when the fraction is zero */
+    FormatTraits[FormatTraits["KeepSingleZero"] = 2] = "KeepSingleZero";
+    /** Zero magnitude returns blank display value */
+    FormatTraits[FormatTraits["ZeroEmpty"] = 4] = "ZeroEmpty";
+    /** Show decimal point when value to right of decimal is empty */
+    FormatTraits[FormatTraits["KeepDecimalPoint"] = 8] = "KeepDecimalPoint";
+    /** Use the rounding factor. Not yet supported  */
+    FormatTraits[FormatTraits["ApplyRounding"] = 16] = "ApplyRounding";
+    /** Show a dash between whole value and fractional value */
+    FormatTraits[FormatTraits["FractionDash"] = 32] = "FractionDash";
+    /** Append the quantity's unit label */
+    FormatTraits[FormatTraits["ShowUnitLabel"] = 64] = "ShowUnitLabel";
+    /** Prepend unit label. Not yet supported */
+    FormatTraits[FormatTraits["PrependUnitLabel"] = 128] = "PrependUnitLabel";
+    /** show a grouping in each group of 1000. */
+    FormatTraits[FormatTraits["Use1000Separator"] = 256] = "Use1000Separator";
+    /** Indicates that if an exponent value is positive to not include a `+`. By default a sign, `+` or `-`, is always shown. Not yet supported */
+    FormatTraits[FormatTraits["ExponentOnlyNegative"] = 512] = "ExponentOnlyNegative";
+})(FormatTraits || (FormatTraits = {}));
+/** Precision for Fractional formatted value types. Range from Whole (1/1) through 1/256.
+ * @beta */
+export var FractionalPrecision;
+(function (FractionalPrecision) {
+    FractionalPrecision[FractionalPrecision["One"] = 1] = "One";
+    FractionalPrecision[FractionalPrecision["Two"] = 2] = "Two";
+    FractionalPrecision[FractionalPrecision["Four"] = 4] = "Four";
+    FractionalPrecision[FractionalPrecision["Eight"] = 8] = "Eight";
+    FractionalPrecision[FractionalPrecision["Sixteen"] = 16] = "Sixteen";
+    FractionalPrecision[FractionalPrecision["ThirtyTwo"] = 32] = "ThirtyTwo";
+    FractionalPrecision[FractionalPrecision["SixtyFour"] = 64] = "SixtyFour";
+    FractionalPrecision[FractionalPrecision["OneHundredTwentyEight"] = 128] = "OneHundredTwentyEight";
+    FractionalPrecision[FractionalPrecision["TwoHundredFiftySix"] = 256] = "TwoHundredFiftySix";
+})(FractionalPrecision || (FractionalPrecision = {}));
+/** Precision for Decimal, Scientific, and Station formatted value types. Range from 1/(10^0) through 1/(10^12).
+ * @beta */
+export var DecimalPrecision;
+(function (DecimalPrecision) {
+    DecimalPrecision[DecimalPrecision["Zero"] = 0] = "Zero";
+    DecimalPrecision[DecimalPrecision["One"] = 1] = "One";
+    DecimalPrecision[DecimalPrecision["Two"] = 2] = "Two";
+    DecimalPrecision[DecimalPrecision["Three"] = 3] = "Three";
+    DecimalPrecision[DecimalPrecision["Four"] = 4] = "Four";
+    DecimalPrecision[DecimalPrecision["Five"] = 5] = "Five";
+    DecimalPrecision[DecimalPrecision["Six"] = 6] = "Six";
+    DecimalPrecision[DecimalPrecision["Seven"] = 7] = "Seven";
+    DecimalPrecision[DecimalPrecision["Eight"] = 8] = "Eight";
+    DecimalPrecision[DecimalPrecision["Nine"] = 9] = "Nine";
+    DecimalPrecision[DecimalPrecision["Ten"] = 10] = "Ten";
+    DecimalPrecision[DecimalPrecision["Eleven"] = 11] = "Eleven";
+    DecimalPrecision[DecimalPrecision["Twelve"] = 12] = "Twelve";
+})(DecimalPrecision || (DecimalPrecision = {}));
+/** Supported format types
+ *  @beta */
+export var FormatType;
+(function (FormatType) {
+    /** Decimal display (ie 2.125) */
+    FormatType[FormatType["Decimal"] = 0] = "Decimal";
+    /** Fractional display (ie 2-1/8) */
+    FormatType[FormatType["Fractional"] = 1] = "Fractional";
+    /** Scientific Notation (ie 1.04e3) */
+    FormatType[FormatType["Scientific"] = 2] = "Scientific";
+    /** Civil Engineering Stationing (ie 1+00). */
+    FormatType[FormatType["Station"] = 3] = "Station";
+})(FormatType || (FormatType = {}));
+/** required if type is scientific
+ * @beta */
+export var ScientificType;
+(function (ScientificType) {
+    /** Non-zero value left of decimal point (ie 1.2345e3) */
+    ScientificType[ScientificType["Normalized"] = 0] = "Normalized";
+    /** Zero value left of decimal point (ie 0.12345e4) */
+    ScientificType[ScientificType["ZeroNormalized"] = 1] = "ZeroNormalized";
+})(ScientificType || (ScientificType = {}));
+/** Determines how the sign of values are displayed
+ * @beta */
+export var ShowSignOption;
+(function (ShowSignOption) {
+    /** Never show a sign even if the value is negative. */
+    ShowSignOption[ShowSignOption["NoSign"] = 0] = "NoSign";
+    /** Only show a sign when the value is negative. */
+    ShowSignOption[ShowSignOption["OnlyNegative"] = 1] = "OnlyNegative";
+    /** Always show a sign whether the value is positive or negative. */
+    ShowSignOption[ShowSignOption["SignAlways"] = 2] = "SignAlways";
+    /** Only show a sign when the value is negative but use parentheses instead of a negative sign. For example, -10 is formatted as `(10)`. */
+    ShowSignOption[ShowSignOption["NegativeParentheses"] = 3] = "NegativeParentheses";
+})(ShowSignOption || (ShowSignOption = {}));
+// parse and toString methods
+/**  @beta   */
+export function parseScientificType(scientificType, formatName) {
+    switch (scientificType.toLowerCase()) {
+        case "normalized": return ScientificType.Normalized;
+        case "zeronormalized": return ScientificType.ZeroNormalized;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'scientificType' attribute.`);
+    }
+}
+/**  @beta   */
+export function scientificTypeToString(scientificType) {
+    return (scientificType === ScientificType.Normalized) ? "Normalized" : "ZeroNormalized";
+}
+/** @beta    */
+export function parseShowSignOption(showSignOption, formatName) {
+    switch (showSignOption.toLowerCase()) {
+        case "nosign": return ShowSignOption.NoSign;
+        case "onlynegative": return ShowSignOption.OnlyNegative;
+        case "signalways": return ShowSignOption.SignAlways;
+        case "negativeparentheses": return ShowSignOption.NegativeParentheses;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'showSignOption' attribute.`);
+    }
+}
+/**  @beta  */
+export function showSignOptionToString(showSign) {
+    switch (showSign) {
+        case ShowSignOption.NegativeParentheses: return "NegativeParentheses";
+        case ShowSignOption.NoSign: return "NoSign";
+        case ShowSignOption.OnlyNegative: return "OnlyNegative";
+        case ShowSignOption.SignAlways: return "SignAlways";
+    }
+}
+/**  @beta  */
+export function parseFormatTrait(formatTraitsString, formatName) {
+    switch (formatTraitsString.toLowerCase()) {
+        case "trailzeroes": return FormatTraits.TrailZeroes;
+        case "keepsinglezero": return FormatTraits.KeepSingleZero;
+        case "zeroempty": return FormatTraits.ZeroEmpty;
+        case "keepdecimalpoint": return FormatTraits.KeepDecimalPoint;
+        case "applyrounding": return FormatTraits.ApplyRounding;
+        case "fractiondash": return FormatTraits.FractionDash;
+        case "showunitlabel": return FormatTraits.ShowUnitLabel;
+        case "prependunitlabel": return FormatTraits.PrependUnitLabel;
+        case "use1000separator": return FormatTraits.Use1000Separator;
+        case "exponentonlynegative": return FormatTraits.ExponentOnlyNegative;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'formatTraits' attribute.`);
+    }
+}
+/** @beta */
+export function getTraitString(trait) {
+    switch (trait) {
+        case FormatTraits.TrailZeroes:
+            return "trailZeroes";
+        case FormatTraits.KeepSingleZero:
+            return "keepSingleZero";
+        case FormatTraits.ZeroEmpty:
+            return "zeroEmpty";
+        case FormatTraits.KeepDecimalPoint:
+            return "keepDecimalPoint";
+        case FormatTraits.ApplyRounding:
+            return "applyRounding";
+        case FormatTraits.FractionDash:
+            return "fractionDash";
+        case FormatTraits.ShowUnitLabel:
+            return "showUnitLabel";
+        case FormatTraits.PrependUnitLabel:
+            return "prependUnitLabel";
+        case FormatTraits.Use1000Separator:
+            return "use1000Separator";
+        case FormatTraits.ExponentOnlyNegative:
+        default:
+            return "exponentOnlyNegative";
+    }
+}
+/**  @beta  */
+export function formatTraitsToArray(currentFormatTrait) {
+    const formatTraitsArr = Array();
+    if ((currentFormatTrait & FormatTraits.TrailZeroes) === FormatTraits.TrailZeroes)
+        formatTraitsArr.push("TrailZeroes");
+    if ((currentFormatTrait & FormatTraits.KeepSingleZero) === FormatTraits.KeepSingleZero)
+        formatTraitsArr.push("KeepSingleZero");
+    if ((currentFormatTrait & FormatTraits.ZeroEmpty) === FormatTraits.ZeroEmpty)
+        formatTraitsArr.push("ZeroEmpty");
+    if ((currentFormatTrait & FormatTraits.KeepDecimalPoint) === FormatTraits.KeepDecimalPoint)
+        formatTraitsArr.push("KeepDecimalPoint");
+    if ((currentFormatTrait & FormatTraits.ApplyRounding) === FormatTraits.ApplyRounding)
+        formatTraitsArr.push("ApplyRounding");
+    if ((currentFormatTrait & FormatTraits.FractionDash) === FormatTraits.FractionDash)
+        formatTraitsArr.push("FractionDash");
+    if ((currentFormatTrait & FormatTraits.ShowUnitLabel) === FormatTraits.ShowUnitLabel)
+        formatTraitsArr.push("ShowUnitLabel");
+    if ((currentFormatTrait & FormatTraits.PrependUnitLabel) === FormatTraits.PrependUnitLabel)
+        formatTraitsArr.push("PrependUnitLabel");
+    if ((currentFormatTrait & FormatTraits.Use1000Separator) === FormatTraits.Use1000Separator)
+        formatTraitsArr.push("Use1000Separator");
+    if ((currentFormatTrait & FormatTraits.ExponentOnlyNegative) === FormatTraits.ExponentOnlyNegative)
+        formatTraitsArr.push("ExponentOnlyNegative");
+    return formatTraitsArr;
+}
+/**  @beta    */
+export function parseFormatType(jsonObjType, formatName) {
+    switch (jsonObjType.toLowerCase()) {
+        case "decimal": return FormatType.Decimal;
+        case "scientific": return FormatType.Scientific;
+        case "station": return FormatType.Station;
+        case "fractional": return FormatType.Fractional;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'type' attribute.`);
+    }
+}
+/** @beta    */
+export function formatTypeToString(type) {
+    switch (type) {
+        case FormatType.Decimal: return "Decimal";
+        case FormatType.Scientific: return "Scientific";
+        case FormatType.Station: return "Station";
+        case FormatType.Fractional: return "Fractional";
+    }
+}
+/**  @beta    */
+export function parseDecimalPrecision(jsonObjPrecision, formatName) {
+    switch (jsonObjPrecision) {
+        case 0: return DecimalPrecision.Zero;
+        case 1: return DecimalPrecision.One;
+        case 2: return DecimalPrecision.Two;
+        case 3: return DecimalPrecision.Three;
+        case 4: return DecimalPrecision.Four;
+        case 5: return DecimalPrecision.Five;
+        case 6: return DecimalPrecision.Six;
+        case 7: return DecimalPrecision.Seven;
+        case 8: return DecimalPrecision.Eight;
+        case 9: return DecimalPrecision.Nine;
+        case 10: return DecimalPrecision.Ten;
+        case 11: return DecimalPrecision.Eleven;
+        case 12: return DecimalPrecision.Twelve;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
+    }
+}
+/**  @beta validates the input value, that is typically extracted for persisted JSON data, is a valid FractionalPrecision */
+export function parseFractionalPrecision(jsonObjPrecision, formatName) {
+    switch (jsonObjPrecision) {
+        case 1: return FractionalPrecision.One;
+        case 2: return FractionalPrecision.Two;
+        case 4: return FractionalPrecision.Four;
+        case 8: return FractionalPrecision.Eight;
+        case 16: return FractionalPrecision.Sixteen;
+        case 32: return FractionalPrecision.ThirtyTwo;
+        case 64: return FractionalPrecision.SixtyFour;
+        case 128: return FractionalPrecision.OneHundredTwentyEight;
+        case 256: return FractionalPrecision.TwoHundredFiftySix;
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
+    }
+}
+/** @beta  validates the input value, that is typically extracted for persisted JSON data, is a valid DecimalPrecision or FractionalPrecision. */
+export function parsePrecision(precision, type, formatName) {
+    switch (type) { // type must be decimal, fractional, scientific, or station
+        case FormatType.Decimal:
+        case FormatType.Scientific:
+        case FormatType.Station:
+            return parseDecimalPrecision(precision, formatName);
+        case FormatType.Fractional:
+            return parseFractionalPrecision(precision, formatName);
+        default:
+            throw new QuantityError(QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'precision' attribute.`);
+    }
+}
 //# sourceMappingURL=FormatEnums.js.map