@genesislcap/foundation-ui 14.304.3-alpha-586ff22.0 → 14.306.0

package/dist/custom-elements.json

@@ -28891,22 +28891,6 @@
               },
               "default": "'en-US'"
             },
-            {
-              "kind": "field",
-              "name": "autoStepPrecision",
-              "type": {
-                "text": "boolean"
-              },
-              "default": "false"
-            },
-            {
-              "kind": "field",
-              "name": "maximumInputPrecision",
-              "type": {
-                "text": "number"
-              },
-              "default": "12"
-            },
             {
               "kind": "field",
               "name": "options",
@@ -29332,29 +29316,6 @@
               "default": "'en-US'",
               "fieldName": "locale"
             },
-            {
-              "type": {
-                "text": "number"
-              },
-              "description": "Indicates that this element should get focus after the page finishes loading. See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefautofocus | autofocus HTML attribute for more information.",
-              "fieldName": "hideStep",
-              "default": "false",
-              "inheritedFrom": {
-                "name": "NumberField",
-                "module": "src/number-field/number-field.ts"
-              }
-            },
-            {
-              "name": "maximumInputPrecision",
-              "type": {
-                "text": "number"
-              },
-              "default": "MAX_INPUT_PRECISION",
-              "resolveInitializer": {
-                "module": "src/number-field/number-field.ts"
-              },
-              "fieldName": "maximumInputPrecision"
-            },
             {
               "name": "readonly",
               "type": {
@@ -29624,39 +29585,27 @@
           "name": "validateValue",
           "return": {
             "type": {
-              "text": ""
+              "text": "string"
             }
           },
           "parameters": [
             {
               "name": "value",
               "type": {
-                "text": "string | number"
-              },
-              "description": "The value to validate and format"
+                "text": "string"
+              }
             },
             {
               "name": "locale",
               "type": {
                 "text": "string"
-              },
-              "description": "The locale to use for formatting"
+              }
             },
             {
               "name": "withFormatting",
-              "default": "true",
-              "description": "Whether to use locale-specific formatting"
-            },
-            {
-              "name": "precision",
-              "optional": true,
-              "type": {
-                "text": "number"
-              },
-              "description": "The precision to use for formatting"
+              "default": "true"
             }
-          ],
-          "description": "Validates and formats a value based on locale and precision"
+          ]
         },
         {
           "kind": "function",
@@ -29678,13 +29627,6 @@
               "type": {
                 "text": "string"
               }
-            },
-            {
-              "name": "precision",
-              "optional": true,
-              "type": {
-                "text": "number"
-              }
             }
           ]
         },
@@ -29724,138 +29666,8 @@
               "type": {
                 "text": "number"
               }
-            },
-            {
-              "name": "precision",
-              "optional": true,
-              "type": {
-                "text": "number"
-              }
             }
           ]
-        },
-        {
-          "kind": "function",
-          "name": "addWithPrecision",
-          "return": {
-            "type": {
-              "text": ""
-            }
-          },
-          "parameters": [
-            {
-              "name": "a",
-              "type": {
-                "text": "number"
-              },
-              "description": "First number"
-            },
-            {
-              "name": "b",
-              "type": {
-                "text": "number"
-              },
-              "description": "Second number"
-            }
-          ],
-          "description": "Performs high precision addition using Pure JavaScript (NO BigInt needed!)\nThis is the BEST solution for precision arithmetic"
-        },
-        {
-          "kind": "function",
-          "name": "subtractWithPrecision",
-          "return": {
-            "type": {
-              "text": ""
-            }
-          },
-          "parameters": [
-            {
-              "name": "a",
-              "type": {
-                "text": "number"
-              },
-              "description": "First number"
-            },
-            {
-              "name": "b",
-              "type": {
-                "text": "number"
-              },
-              "description": "Second number"
-            }
-          ],
-          "description": "Performs high precision subtraction using Pure JavaScript"
-        },
-        {
-          "kind": "function",
-          "name": "incrementWithPrecision",
-          "return": {
-            "type": {
-              "text": ""
-            }
-          },
-          "parameters": [
-            {
-              "name": "valueString",
-              "type": {
-                "text": "string | number"
-              },
-              "description": "The value as a string to maintain precision"
-            },
-            {
-              "name": "step",
-              "type": {
-                "text": "number"
-              },
-              "description": "The step value to add"
-            }
-          ],
-          "description": "Increment a value with precision using direct string manipulation"
-        },
-        {
-          "kind": "function",
-          "name": "decrementWithPrecision",
-          "return": {
-            "type": {
-              "text": ""
-            }
-          },
-          "parameters": [
-            {
-              "name": "valueString",
-              "type": {
-                "text": "string | number"
-              },
-              "description": "The value as a string to maintain precision"
-            },
-            {
-              "name": "step",
-              "type": {
-                "text": "number"
-              },
-              "description": "The step value to subtract"
-            }
-          ],
-          "description": "Decrement a value with precision using direct string manipulation"
-        },
-        {
-          "kind": "function",
-          "name": "calculateAutoStepPrecision",
-          "return": {
-            "type": {
-              "text": ""
-            }
-          },
-          "parameters": [
-            {
-              "name": "value",
-              "type": {
-                "text": "string | number"
-              },
-              "description": "The value to calculate step precision for"
-            }
-          ],
-          "description": "Calculate auto step precision based on decimal places\nMaintains original step calculation for compatibility"
         }
       ],
       "exports": [
@@ -29922,46 +29734,6 @@
             "name": "validateMinMax",
             "module": "src/number-field/utils.ts"
           }
-        },
-        {
-          "kind": "js",
-          "name": "addWithPrecision",
-          "declaration": {
-            "name": "addWithPrecision",
-            "module": "src/number-field/utils.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "subtractWithPrecision",
-          "declaration": {
-            "name": "subtractWithPrecision",
-            "module": "src/number-field/utils.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "incrementWithPrecision",
-          "declaration": {
-            "name": "incrementWithPrecision",
-            "module": "src/number-field/utils.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "decrementWithPrecision",
-          "declaration": {
-            "name": "decrementWithPrecision",
-            "module": "src/number-field/utils.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "calculateAutoStepPrecision",
-          "declaration": {
-            "name": "calculateAutoStepPrecision",
-            "module": "src/number-field/utils.ts"
-          }
         }
       ]
     },
@@ -41462,6 +41234,14 @@
               },
               "default": "false"
             },
+            {
+              "kind": "field",
+              "name": "allowForwardJumps",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false"
+            },
             {
               "kind": "field",
               "name": "orientation",
@@ -41605,6 +41385,42 @@
                 }
               ]
             },
+            {
+              "kind": "method",
+              "name": "handleBackwardJump",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "targetStepIndex",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "handleForwardJump",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "targetStepIndex",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ]
+            },
             {
               "kind": "field",
               "name": "disabledPreviousStep",
@@ -41821,6 +41637,14 @@
               "default": "false",
               "fieldName": "allowBackwardJumps"
             },
+            {
+              "name": "allow-forward-jumps",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "fieldName": "allowForwardJumps"
+            },
             {
               "name": "orientation",
               "type": {

package/dist/dts/number-field/number-field.d.ts

@@ -10,8 +10,6 @@ export declare class NumberField extends FASTNumberField {
     value: string;
     withFormatting: boolean;
     locale: string;
-    autoStepPrecision: boolean;
-    maximumInputPrecision: number;
     options: Intl.NumberFormatOptions;
     stepUp(): void;
     stepDown(): void;

package/dist/dts/number-field/number-field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number-field.d.ts","sourceRoot":"","sources":["../../../src/number-field/number-field.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAgBrE;;GAEG;AACH,qBAAa,WAAY,SAAQ,eAAe;IACxC,YAAY,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,mBAAmB;IAKA,QAAQ,EAAE,OAAO,CAAS;IAC/C,KAAK,EAAE,MAAM,CAAM;IACE,cAAc,EAAE,OAAO,CAAS;IACrD,MAAM,EAAE,MAAM,CAAW;IACJ,iBAAiB,EAAE,OAAO,CAAS;IACxD,qBAAqB,EAAE,MAAM,CAAuB;IAE1D,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAG/B;IAEF,MAAM,IAAI,IAAI;IAuCd,QAAQ,IAAI,IAAI;IA0ChB,2BAA2B;IAK3B,eAAe,IAAI,IAAI;IAiCvB,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IA+C5C,UAAU,IAAI,IAAI;CA0BnB;AAED,eAAO,MAAM,kCAAkC,EAAE,cAGhD,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;CAWpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,oTAMhC,CAAC"}
+{"version":3,"file":"number-field.d.ts","sourceRoot":"","sources":["../../../src/number-field/number-field.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAOrE;;GAEG;AACH,qBAAa,WAAY,SAAQ,eAAe;IACxC,YAAY,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,mBAAmB;IAKA,QAAQ,EAAE,OAAO,CAAS;IAC/C,KAAK,EAAE,MAAM,CAAM;IACE,cAAc,EAAE,OAAO,CAAS;IACrD,MAAM,EAAE,MAAM,CAAW;IAE/B,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAG/B;IAEF,MAAM,IAAI,IAAI;IAuBd,QAAQ,IAAI,IAAI;IAuBhB,2BAA2B;IAK3B,eAAe,IAAI,IAAI;IAuBvB,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAoC5C,UAAU,IAAI,IAAI;CAsBnB;AAED,eAAO,MAAM,kCAAkC,EAAE,cAGhD,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;CAWpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,oTAMhC,CAAC"}

package/dist/dts/number-field/number-field.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number-field.template.d.ts","sourceRoot":"","sources":["../../../src/number-field/number-field.template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAGL,yBAAyB,EACzB,kBAAkB,EAEnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,yBAAyB,CACnE,YAAY,CAAC,WAAW,CAAC,EACzB,kBAAkB,CA0EnB,CAAC"}
+{"version":3,"file":"number-field.template.d.ts","sourceRoot":"","sources":["../../../src/number-field/number-field.template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAGL,yBAAyB,EACzB,kBAAkB,EAEnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,yBAAyB,CACnE,YAAY,CAAC,WAAW,CAAC,EACzB,kBAAkB,CA0EnB,CAAC"}

package/dist/dts/number-field/utils.d.ts

@@ -5,51 +5,7 @@ export declare const formatControlValue: (value: string, locale: string) => stri
 export declare const sanitiseInputVal: (inputVal: string, locale: string) => string;
 export declare const toIntlNumberFormat: (value: string, locale: string, options: Intl.NumberFormatOptions) => string;
 export declare const preserveTrailingZerosAfterParse: (value: string, parsedValue: string, locale: string) => string;
-/**
- * Validates and formats a value based on locale and precision
- * @param value - The value to validate and format
- * @param locale - The locale to use for formatting
- * @param withFormatting - Whether to use locale-specific formatting
- * @param precision - The precision to use for formatting
- * @returns The validated and formatted value
- */
-export declare const validateValue: (value: string | number, locale: string, withFormatting?: boolean, precision?: number) => string;
-export declare const validateInput: (value: string, locale: string, precision?: number) => string;
-export declare const validateMinMax: (value: string, locale: string, withFormatting: boolean, min: number, max: number, precision?: number) => string;
-/**
- * Performs high precision addition using Pure JavaScript (NO BigInt needed!)
- * This is the BEST solution for precision arithmetic
- * @param a - First number
- * @param b - Second number
- * @returns Sum with maintained precision
- */
-export declare const addWithPrecision: (a: number, b: number) => number;
-/**
- * Performs high precision subtraction using Pure JavaScript
- * @param a - First number
- * @param b - Second number
- * @returns Difference with maintained precision
- */
-export declare const subtractWithPrecision: (a: number, b: number) => number;
-/**
- * Increment a value with precision using direct string manipulation
- * @param valueString - The value as a string to maintain precision
- * @param step - The step value to add
- * @returns The incremented value as a string with preserved precision
- */
-export declare const incrementWithPrecision: (valueString: string | number, step: number) => string;
-/**
- * Decrement a value with precision using direct string manipulation
- * @param valueString - The value as a string to maintain precision
- * @param step - The step value to subtract
- * @returns The decremented value as a string with preserved precision
- */
-export declare const decrementWithPrecision: (valueString: string | number, step: number) => string;
-/**
- * Calculate auto step precision based on decimal places
- * Maintains original step calculation for compatibility
- * @param value - The value to calculate step precision for
- * @returns The calculated step value
- */
-export declare const calculateAutoStepPrecision: (value: string | number) => number;
+export declare const validateValue: (value: string, locale: string, withFormatting?: boolean) => string;
+export declare const validateInput: (value: string, locale: string) => string;
+export declare const validateMinMax: (value: string, locale: string, withFormatting: boolean, min: number, max: number) => string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/dts/number-field/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/number-field/utils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,GAClC,OAAO,MAAM,EACb,QAAQ,MAAM,KACb;IAAE,gBAAgB,EAAE,MAAM,CAAA;CAI5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAWlE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,QAAQ,MAAM,KAAG,MAEnE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,SAAS,IAAI,CAAC,mBAAmB,KAChC,MAEF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,OAAO,MAAM,EACb,aAAa,MAAM,EACnB,QAAQ,MAAM,KACb,MA+BF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,GAAG,MAAM,EACtB,QAAQ,MAAM,EACd,wBAAqB,EACrB,YAAY,MAAM,KACjB,MA8DF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,EAAE,YAAY,MAAM,KAAG,MAGjF,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,uBAAqB,EACrB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,YAAY,MAAM,KACjB,MAaF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAyBvD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAyB5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,GAAG,MAAM,EAAE,MAAM,MAAM,KAAG,MAiDnF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,GAAG,MAAM,EAAE,MAAM,MAAM,KAAG,MAiDnF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,OAAO,MAAM,GAAG,MAAM,KAAG,MA8BnE,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/number-field/utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB,GAClC,OAAO,MAAM,EACb,QAAQ,MAAM,KACb;IAAE,gBAAgB,EAAE,MAAM,CAAA;CAI5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAWlE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,QAAQ,MAAM,KAAG,MAEnE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,SAAS,IAAI,CAAC,mBAAmB,KAChC,MAEF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,OAAO,MAAM,EACb,aAAa,MAAM,EACnB,QAAQ,MAAM,KACb,MA+BF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,EAAE,wBAAqB,KAAG,MAYpF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAG7D,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,QAAQ,MAAM,EACd,uBAAqB,EACrB,KAAK,MAAM,EACX,KAAK,MAAM,KACV,MAWF,CAAC"}

package/dist/dts/stepper/stepper.d.ts

@@ -10,6 +10,7 @@ export declare class Stepper extends FoundationElement {
     hideSubmitButton: boolean;
     hideStepNumber: boolean;
     allowBackwardJumps: boolean;
+    allowForwardJumps: boolean;
     orientation: TabsOrientation;
     orientationChanged(): void;
     activeid: string;
@@ -27,6 +28,8 @@ export declare class Stepper extends FoundationElement {
     connectedCallback(): void;
     private getActiveIndex;
     handleStepClick(stepIndex: any): void;
+    private handleBackwardJump;
+    private handleForwardJump;
     get disabledPreviousStep(): boolean;
     get isLastStep(): boolean;
     get islastStepValid(): boolean;

package/dist/dts/stepper/stepper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stepper.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI5C,MAAM,MAAM,UAAU,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,CAAA;CAAE,CAAC;AAEhD;;GAEG;AACH,qBAAa,OAAQ,SAAQ,iBAAiB;IACgB,gBAAgB,EAAE,OAAO,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAS;IAC5F,WAAW,EAAE,eAAe,CAA4B;IAC9D,kBAAkB,IAAI,IAAI;IAOpB,QAAQ,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQ7C,IAAI,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,CAAC;IAC/C,WAAW,IAAI,IAAI;IAWP,SAAS,EAAE,WAAW,EAAE,CAAC;IACrC,gBAAgB,IAAI,IAAI;IAUZ,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,aAAa,SAAK;IAClB,cAAc,EAAE,MAAM,CAAK;IAEvC,SAAS,EAAE,WAAW,CAAC;IACvB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,WAAW,CAAgB;IAEnC,iBAAiB,IAAI,IAAI;IAQzB,OAAO,CAAC,cAAc;IAStB,eAAe,CAAC,SAAS,KAAA;IAczB,IAAc,oBAAoB,YAEjC;IAED,IAAc,UAAU,YAEvB;IAED,IAAc,eAAe,YAkB5B;IAED,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,IAAI;IAqChB,YAAY,IAAI,IAAI;IAQpB,SAAS,CAAC,OAAO,QAAO,IAAI,CAkC1B;IAEF,gBAAgB,aAWd;IAEF,OAAO,CAAC,YAAY,CAUlB;IAEF,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,mBAAmB;CAG5B;AAGD,eAAO,MAAM,8BAA8B,EAAE,cAA0B,CAAC;AAExE,eAAO,MAAM,oBAAoB,IAAK,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;kBAM5B,CAAC"}
+{"version":3,"file":"stepper.d.ts","sourceRoot":"","sources":["../../../src/stepper/stepper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI5C,MAAM,MAAM,UAAU,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,CAAA;CAAE,CAAC;AAEhD;;GAEG;AACH,qBAAa,OAAQ,SAAQ,iBAAiB;IACgB,gBAAgB,EAAE,OAAO,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAS;IACrC,iBAAiB,EAAE,OAAO,CAAS;IAC1F,WAAW,EAAE,eAAe,CAA4B;IAC9D,kBAAkB,IAAI,IAAI;IAOpB,QAAQ,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQ7C,IAAI,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,CAAC;IAC/C,WAAW,IAAI,IAAI;IAWP,SAAS,EAAE,WAAW,EAAE,CAAC;IACrC,gBAAgB,IAAI,IAAI;IAUZ,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,aAAa,SAAK;IAClB,cAAc,EAAE,MAAM,CAAK;IAEvC,SAAS,EAAE,WAAW,CAAC;IACvB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,WAAW,CAAgB;IAEnC,iBAAiB,IAAI,IAAI;IAQzB,OAAO,CAAC,cAAc;IAStB,eAAe,CAAC,SAAS,KAAA;IAQzB,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,iBAAiB;IAwCzB,IAAc,oBAAoB,YAEjC;IAED,IAAc,UAAU,YAEvB;IAED,IAAc,eAAe,YAkB5B;IAED,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,IAAI;IAqChB,YAAY,IAAI,IAAI;IAQpB,SAAS,CAAC,OAAO,QAAO,IAAI,CAqC1B;IAEF,gBAAgB,aAWd;IAEF,OAAO,CAAC,YAAY,CAUlB;IAEF,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,mBAAmB;CAG5B;AAGD,eAAO,MAAM,8BAA8B,EAAE,cAA0B,CAAC;AAExE,eAAO,MAAM,oBAAoB,IAAK,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;kBAM5B,CAAC"}

package/dist/esm/number-field/number-field.js

@@ -4,9 +4,8 @@ import { NumberField as FASTNumberField } from '@microsoft/fast-components';
 import { DOM, attr } from '@microsoft/fast-element';
 import { foundationNumberFieldStyles as styles } from './number-field.styles';
 import { foundationNumberFieldTemplate as template } from './number-field.template';
-import { calculateAutoStepPrecision, decrementWithPrecision, formatControlValue, incrementWithPrecision, toIntlNumberFormat, validateInput, validateMinMax, } from './utils';
+import { formatControlValue, toIntlNumberFormat, validateInput, validateMinMax } from './utils';
 const MAX_DECIMAL_PLACES = 3;
-const MAX_INPUT_PRECISION = 12;
 /**
  * @tagname %%prefix%%-number-field
  */
@@ -17,8 +16,6 @@ export class NumberField extends FASTNumberField {
         this.value = '';
         this.withFormatting = false;
         this.locale = 'en-US';
-        this.autoStepPrecision = false;
-        this.maximumInputPrecision = MAX_INPUT_PRECISION;
         this.options = {
             maximumFractionDigits: MAX_DECIMAL_PLACES,
             minimumFractionDigits: 0,
@@ -30,60 +27,33 @@ export class NumberField extends FASTNumberField {
         }
     }
     stepUp() {
-        const isValidNumber = /^-?\d*\.?\d+$/.test(this.value) && this.value !== '';
-        if (!isValidNumber) {
-            const stepUpValue = this.min > 0 ? this.min : this.max < 0 ? this.max : !this.min ? this.step : 0;
-            this.value = stepUpValue.toString();
-        }
-        else {
-            let stepValue;
-            if (this.autoStepPrecision) {
-                stepValue = calculateAutoStepPrecision(this.value);
-            }
-            else {
-                stepValue = this.step;
-            }
-            const stepUpValue = incrementWithPrecision(this.value, stepValue);
-            this.value = stepUpValue.toString();
-        }
-        if (this.control) {
-            if (this.min !== undefined || this.max !== undefined) {
-                this.control.value = validateMinMax(this.value, this.locale, this.withFormatting, this.min, this.max, this.maximumInputPrecision);
-            }
-            else {
-                this.control.value = this.value;
-            }
-        }
+        const value = parseFloat(this.value);
+        const stepUpValue = !isNaN(value)
+            ? value + this.step
+            : this.min > 0
+                ? this.min
+                : this.max < 0
+                    ? this.max
+                    : !this.min
+                        ? this.step
+                        : 0;
+        this.value = stepUpValue.toString();
+        this.control.value = validateMinMax(stepUpValue.toString(), this.locale, this.withFormatting, this.min, this.max);
         this.handleTextInput();
     }
     stepDown() {
-        // Check if the string represents a valid number without losing precision
-        const isValidNumber = /^-?\d*\.?\d+$/.test(this.value) && this.value !== '';
-        if (!isValidNumber) {
-            // Handle invalid value case
-            const stepDownValue = this.min > 0 ? this.min : this.max < 0 ? this.max : !this.min ? 0 - this.step : 0;
-            this.value = stepDownValue.toString();
-        }
-        else {
-            // Use precision-aware decrement
-            let stepValue;
-            if (this.autoStepPrecision) {
-                stepValue = calculateAutoStepPrecision(this.value);
-            }
-            else {
-                stepValue = this.step;
-            }
-            const stepDownValue = decrementWithPrecision(this.value, stepValue);
-            this.value = stepDownValue.toString();
-        }
-        if (this.control) {
-            if (this.min !== undefined || this.max !== undefined) {
-                this.control.value = validateMinMax(this.value, this.locale, this.withFormatting, this.min, this.max, this.maximumInputPrecision);
-            }
-            else {
-                this.control.value = this.value;
-            }
-        }
+        const value = parseFloat(this.value);
+        const stepDownValue = !isNaN(value)
+            ? value - this.step
+            : this.min > 0
+                ? this.min
+                : this.max < 0
+                    ? this.max
+                    : !this.min
+                        ? 0 - this.step
+                        : 0;
+        this.value = stepDownValue.toString();
+        this.control.value = validateMinMax(stepDownValue.toString(), this.locale, this.withFormatting, this.min, this.max);
         this.handleTextInput();
     }
     hasSeparatorWithoutDecimals() {
@@ -91,29 +61,22 @@ export class NumberField extends FASTNumberField {
         return new RegExp(regexString);
     }
     handleTextInput() {
-        if (!this.control)
-            return;
         if (this.control.value === '-' || this.control.value === '-0')
             return;
         this['isUserInput'] = true;
         if (this.withFormatting && !new NumberParser(this.locale).hasSeparator(this.control.value)) {
             DOM.queueUpdate(() => {
-                const validValue = validateInput(this.control.value, this.locale, this.maximumInputPrecision);
+                const validValue = validateInput(this.control.value, this.locale);
                 this.value = validValue;
-                if (this.control) {
-                    this.control.value = formatControlValue(validValue, this.locale);
-                }
+                this.control.value = formatControlValue(validValue, this.locale);
                 this.$emit('input');
             });
         }
         else if (!this.withFormatting &&
             !this.hasSeparatorWithoutDecimals().test(this.control.value)) {
             DOM.queueUpdate(() => {
-                var _a;
-                if (this.control) {
-                    this.control.value = this.control.value.replace(/[^0-9\-+e.]/g, '');
-                }
-                this.value = ((_a = this.control) === null || _a === void 0 ? void 0 : _a.value) || '';
+                this.control.value = this.control.value.replace(/[^0-9\-+e.]/g, '');
+                this.value = this.control.value;
                 this.$emit('input');
             });
         }
@@ -125,41 +88,37 @@ export class NumberField extends FASTNumberField {
         }
         if (next !== undefined && next !== null && next !== previous) {
             if (!this['isUserInput']) {
-                this.value = validateMinMax(this.value, this.locale, false, this.min, this.max, this.maximumInputPrecision);
+                this.value = validateMinMax(this.value, this.locale, false, this.min, this.max);
                 DOM.queueUpdate(() => {
-                    if (this.control) {
-                        this.control.value =
-                            this.withFormatting && this.value
-                                ? toIntlNumberFormat(this.value, this.locale, this.options)
-                                : this.value;
-                    }
+                    this.control.value =
+                        this.withFormatting && this.value
+                            ? toIntlNumberFormat(this.value, this.locale, this.options)
+                            : this.value;
                 });
                 return;
             }
             const value = next;
             DOM.queueUpdate(() => {
-                if (!this.control)
-                    return;
-                if (this.control.value === '' || this.value === '') {
+                var _a;
+                if (((_a = this.control) === null || _a === void 0 ? void 0 : _a.value) === '' || this.value === '') {
                     this.control.value = value;
                     return;
                 }
                 this.control.value = formatControlValue(String(value), this.locale);
                 this.value = this.withFormatting
-                    ? validateInput(this.control.value, this.locale, this.maximumInputPrecision)
+                    ? validateInput(this.control.value, this.locale)
                     : this.control.value;
             });
         }
     }
     handleBlur() {
-        if (!this.control)
-            return;
         this['isUserInput'] = false;
-        const validatedValue = validateMinMax(this.control.value, this.locale, this.withFormatting, this.min, this.max, this.maximumInputPrecision);
-        // Preserve precision by avoiding parseFloat
-        if (validatedValue && /^-?\d*\.?\d+$/.test(validatedValue)) {
-            // Use the validated string value directly to preserve precision
-            this.value = validatedValue;
+        const validatedValue = validateMinMax(this.control.value, this.locale, this.withFormatting, this.min, this.max);
+        if (validatedValue && !isNaN(parseFloat(validatedValue))) {
+            this.value = Intl.NumberFormat('en-US', {
+                maximumFractionDigits: this.options.maximumFractionDigits,
+                useGrouping: false,
+            }).format(parseFloat(validatedValue));
         }
         this.control.value =
             this.withFormatting && this.value
@@ -183,12 +142,6 @@ __decorate([
 __decorate([
     attr
 ], NumberField.prototype, "locale", void 0);
-__decorate([
-    attr({ mode: 'boolean' })
-], NumberField.prototype, "autoStepPrecision", void 0);
-__decorate([
-    attr
-], NumberField.prototype, "maximumInputPrecision", void 0);
 export const foundationNumberFieldShadowOptions = {
     delegatesFocus: true,
     mode: 'open',

package/dist/esm/number-field/utils.js

@@ -1,7 +1,6 @@
 import { NumberParser } from '@genesislcap/foundation-utils';
 const formattedInputPrecision = 12;
 const FORMAT_TEST_NUMBER = 12345.6;
-const DECIMAL_BASE = 10;
 export const getSeparatorsFromParser = (value, locale) => {
     var _a;
     const parts = new Intl.NumberFormat(locale).formatToParts(FORMAT_TEST_NUMBER);
@@ -50,75 +49,19 @@ export const preserveTrailingZerosAfterParse = (value, parsedValue, locale) => {
     }
     return String(parsedValue);
 };
-/**
- * Validates and formats a value based on locale and precision
- * @param value - The value to validate and format
- * @param locale - The locale to use for formatting
- * @param withFormatting - Whether to use locale-specific formatting
- * @param precision - The precision to use for formatting
- * @returns The validated and formatted value
- */
-export const validateValue = (value, locale, withFormatting = true, precision) => {
-    if (value === undefined || value === null || value === '') {
-        return '';
-    }
-    const stringValue = typeof value === 'number' ? value.toString() : value;
-    const inputPrecision = precision !== null && precision !== void 0 ? precision : formattedInputPrecision;
-    let cleanValue;
-    if (withFormatting) {
-        cleanValue = sanitiseInputVal(stringValue, locale);
-    }
-    else {
-        const { decimalSeparator } = getSeparatorsFromParser(stringValue, locale);
-        if (decimalSeparator !== '.') {
-            const normalizedValue = stringValue.replace(new RegExp(`\\${decimalSeparator}`, 'g'), '.');
-            cleanValue = normalizedValue;
-            const decimalIndex = cleanValue.indexOf('.');
-            if (decimalIndex !== -1) {
-                cleanValue = cleanValue.substring(0, decimalIndex);
-            }
-        }
-        else {
-            cleanValue = stringValue;
-        }
-    }
-    // Ensure cleanValue is always a string (single conversion point)
-    cleanValue = String(cleanValue);
-    const numberRegex = /^-?\d*\.?\d+$/;
-    if (!numberRegex.test(cleanValue)) {
-        return '';
-    }
-    if (inputPrecision !== undefined) {
-        const cleanValueStr = cleanValue.replace('.', '');
-        const significantDigits = cleanValueStr.replace(/^0+/, '').length;
-        if (significantDigits > inputPrecision) {
-            const decimalIndex = cleanValue.indexOf('.');
-            if (decimalIndex !== -1) {
-                const integerPart = cleanValue.substring(0, decimalIndex);
-                const integerDigits = integerPart.length;
-                if (integerDigits >= inputPrecision) {
-                    return cleanValue.substring(0, inputPrecision);
-                }
-                else {
-                    const decimalDigitsNeeded = inputPrecision - integerDigits;
-                    const decimalPart = cleanValue.substring(decimalIndex + 1);
-                    const truncatedDecimalPart = decimalPart.substring(0, decimalDigitsNeeded);
-                    return `${integerPart}.${truncatedDecimalPart}`;
-                }
-            }
-            else {
-                return cleanValue.substring(0, inputPrecision);
-            }
-        }
+export const validateValue = (value, locale, withFormatting = true) => {
+    let validValue = parseFloat(parseFloat(withFormatting ? sanitiseInputVal(value, locale) : value).toPrecision(formattedInputPrecision));
+    if (isNaN(validValue)) {
+        validValue = '';
     }
-    return cleanValue;
+    return String(validValue);
 };
-export const validateInput = (value, locale, precision) => {
-    const parsedValue = validateValue(value, locale, undefined, precision);
+export const validateInput = (value, locale) => {
+    const parsedValue = validateValue(value, locale);
     return preserveTrailingZerosAfterParse(value, parsedValue, locale);
 };
-export const validateMinMax = (value, locale, withFormatting = true, min, max, precision) => {
-    let validValue = parseFloat(validateValue(value, locale, withFormatting, precision));
+export const validateMinMax = (value, locale, withFormatting = true, min, max) => {
+    let validValue = parseFloat(validateValue(value, locale, withFormatting));
     if (isNaN(validValue)) {
         validValue = '';
     }
@@ -128,194 +71,3 @@ export const validateMinMax = (value, locale, withFormatting = true, min, max, p
     }
     return String(validValue);
 };
-/**
- * Performs high precision addition using Pure JavaScript (NO BigInt needed!)
- * This is the BEST solution for precision arithmetic
- * @param a - First number
- * @param b - Second number
- * @returns Sum with maintained precision
- */
-export const addWithPrecision = (a, b) => {
-    try {
-        const aStr = a.toString();
-        const bStr = b.toString();
-        const aDecimalIndex = aStr.indexOf('.');
-        const bDecimalIndex = bStr.indexOf('.');
-        const aPrecision = aDecimalIndex === -1 ? 0 : aStr.length - aDecimalIndex - 1;
-        const bPrecision = bDecimalIndex === -1 ? 0 : bStr.length - bDecimalIndex - 1;
-        const maxPrecision = Math.max(aPrecision, bPrecision);
-        const multiplier = Math.pow(DECIMAL_BASE, maxPrecision);
-        const aInt = Math.round(a * multiplier);
-        const bInt = Math.round(b * multiplier);
-        const resultInt = aInt + bInt;
-        return resultInt / multiplier;
-    }
-    catch (error) {
-        // fallback
-        return a + b;
-    }
-};
-/**
- * Performs high precision subtraction using Pure JavaScript
- * @param a - First number
- * @param b - Second number
- * @returns Difference with maintained precision
- */
-export const subtractWithPrecision = (a, b) => {
-    try {
-        const aStr = a.toString();
-        const bStr = b.toString();
-        const aDecimalIndex = aStr.indexOf('.');
-        const bDecimalIndex = bStr.indexOf('.');
-        const aPrecision = aDecimalIndex === -1 ? 0 : aStr.length - aDecimalIndex - 1;
-        const bPrecision = bDecimalIndex === -1 ? 0 : bStr.length - bDecimalIndex - 1;
-        const maxPrecision = Math.max(aPrecision, bPrecision);
-        const multiplier = Math.pow(DECIMAL_BASE, maxPrecision);
-        const aInt = Math.round(a * multiplier);
-        const bInt = Math.round(b * multiplier);
-        const resultInt = aInt - bInt;
-        return resultInt / multiplier;
-    }
-    catch (error) {
-        // fallback
-        return a - b;
-    }
-};
-/**
- * Increment a value with precision using direct string manipulation
- * @param valueString - The value as a string to maintain precision
- * @param step - The step value to add
- * @returns The incremented value as a string with preserved precision
- */
-export const incrementWithPrecision = (valueString, step) => {
-    try {
-        const valueStr = typeof valueString === 'string' ? valueString : valueString.toString();
-        const decimalIndex = valueStr.indexOf('.');
-        if (decimalIndex === -1) {
-            const value = parseInt(valueStr);
-            return (value + step).toString();
-        }
-        const decimalPart = valueStr.substring(decimalIndex + 1);
-        const decimalPlaces = decimalPart.length;
-        const lastDigitIndex = decimalPart.length - 1;
-        const lastDigit = parseInt(decimalPart.charAt(lastDigitIndex));
-        const newLastDigit = lastDigit + 1;
-        if (newLastDigit <= 9) {
-            const newDecimalPart = decimalPart.substring(0, lastDigitIndex) + newLastDigit;
-            return valueStr.substring(0, decimalIndex + 1) + newDecimalPart;
-        }
-        else {
-            let newDecimalPart = '';
-            let carry = 1;
-            for (let i = lastDigitIndex; i >= 0; i -= 1) {
-                const digit = parseInt(decimalPart.charAt(i));
-                const newDigit = digit + carry;
-                if (newDigit <= 9) {
-                    newDecimalPart = newDigit + newDecimalPart;
-                    carry = 0;
-                }
-                else {
-                    newDecimalPart = '0' + newDecimalPart;
-                    carry = 1;
-                }
-            }
-            if (carry === 1) {
-                const integerPart = parseInt(valueStr.substring(0, decimalIndex));
-                return integerPart + 1 + '.' + newDecimalPart;
-            }
-            else {
-                return valueStr.substring(0, decimalIndex + 1) + newDecimalPart;
-            }
-        }
-    }
-    catch (error) {
-        const value = typeof valueString === 'string' ? parseFloat(valueString) : valueString;
-        return (value + step).toString();
-    }
-};
-/**
- * Decrement a value with precision using direct string manipulation
- * @param valueString - The value as a string to maintain precision
- * @param step - The step value to subtract
- * @returns The decremented value as a string with preserved precision
- */
-export const decrementWithPrecision = (valueString, step) => {
-    try {
-        const valueStr = typeof valueString === 'string' ? valueString : valueString.toString();
-        const decimalIndex = valueStr.indexOf('.');
-        if (decimalIndex === -1) {
-            const value = parseInt(valueStr);
-            return (value - step).toString();
-        }
-        const decimalPart = valueStr.substring(decimalIndex + 1);
-        const decimalPlaces = decimalPart.length;
-        const lastDigitIndex = decimalPart.length - 1;
-        const lastDigit = parseInt(decimalPart.charAt(lastDigitIndex));
-        const newLastDigit = lastDigit - 1;
-        if (newLastDigit >= 0) {
-            const newDecimalPart = decimalPart.substring(0, lastDigitIndex) + newLastDigit;
-            return valueStr.substring(0, decimalIndex + 1) + newDecimalPart;
-        }
-        else {
-            let newDecimalPart = '';
-            let borrow = 1;
-            for (let i = lastDigitIndex; i >= 0; i -= 1) {
-                const digit = parseInt(decimalPart.charAt(i));
-                const newDigit = digit - borrow;
-                if (newDigit >= 0) {
-                    newDecimalPart = newDigit + newDecimalPart;
-                    borrow = 0;
-                }
-                else {
-                    newDecimalPart = '9' + newDecimalPart;
-                    borrow = 1;
-                }
-            }
-            if (borrow === 1) {
-                const integerPart = parseInt(valueStr.substring(0, decimalIndex));
-                return integerPart - 1 + '.' + newDecimalPart;
-            }
-            else {
-                return valueStr.substring(0, decimalIndex + 1) + newDecimalPart;
-            }
-        }
-    }
-    catch (error) {
-        const value = typeof valueString === 'string' ? parseFloat(valueString) : valueString;
-        return (value - step).toString();
-    }
-};
-/**
- * Calculate auto step precision based on decimal places
- * Maintains original step calculation for compatibility
- * @param value - The value to calculate step precision for
- * @returns The calculated step value
- */
-export const calculateAutoStepPrecision = (value) => {
-    try {
-        const valueStr = typeof value === 'string' ? value : value.toString();
-        const decimalIndex = valueStr.indexOf('.');
-        if (decimalIndex === -1) {
-            return 1;
-        }
-        const decimalPart = valueStr.substring(decimalIndex + 1);
-        const decimalPlaces = decimalPart.length;
-        if (decimalPlaces === 0) {
-            return 1;
-        }
-        const step = Math.pow(DECIMAL_BASE, -decimalPlaces);
-        return parseFloat(step.toFixed(decimalPlaces));
-    }
-    catch (error) {
-        const valueStr = typeof value === 'string' ? value : value.toString();
-        const decimalIndex = valueStr.indexOf('.');
-        if (decimalIndex === -1)
-            return 1;
-        const decimalPart = valueStr.substring(decimalIndex + 1);
-        const decimalPlaces = decimalPart.length;
-        if (decimalPlaces === 0)
-            return 1;
-        const step = Math.pow(DECIMAL_BASE, -decimalPlaces);
-        return parseFloat(step.toFixed(decimalPlaces));
-    }
-};

package/dist/esm/stepper/stepper.js

@@ -11,6 +11,7 @@ export class Stepper extends FoundationElement {
     constructor() {
         super(...arguments);
         this.allowBackwardJumps = false;
+        this.allowForwardJumps = false;
         this.orientation = TabsOrientation.vertical;
         this.progressValue = 0;
         this.activeTabIndex = 0;
@@ -33,7 +34,8 @@ export class Stepper extends FoundationElement {
                     tab.setAttribute('isLast', String(isLast));
                     tab.setAttribute('hideStepNumber', String(this.hideStepNumber === true));
                     tab.setAttribute('tabindex', isActiveTab ? '0' : '-1');
-                    tab.setAttribute('showCursorPointer', String(index <= this.activeTabIndex && this.allowBackwardJumps));
+                    tab.setAttribute('showCursorPointer', String((index <= this.activeTabIndex && this.allowBackwardJumps) ||
+                        (index > this.activeTabIndex && this.allowForwardJumps)));
                     if (isActiveTab) {
                         this.activetab = tab;
                         this.activeid = tabId;
@@ -113,16 +115,56 @@ export class Stepper extends FoundationElement {
     }
     handleStepClick(stepIndex) {
         if (stepIndex < this.activeTabIndex && this.allowBackwardJumps) {
-            for (let i = stepIndex + 1; i <= this.activeTabIndex; i = i + 1) {
-                this.tabs[i].completed = false;
+            this.handleBackwardJump(stepIndex);
+        }
+        else if (stepIndex > this.activeTabIndex && this.allowForwardJumps) {
+            this.handleForwardJump(stepIndex);
+        }
+    }
+    handleBackwardJump(targetStepIndex) {
+        // Reset completion status for all steps after the clicked step
+        for (let i = targetStepIndex + 1; i <= this.activeTabIndex; i = i + 1) {
+            this.tabs[i].completed = false;
+        }
+        this.activetab = this.tabs[targetStepIndex];
+        this.activeid = this.tabIds[targetStepIndex];
+        this.$emit('step-click', {
+            activetab: this.activetab,
+            activeid: this.activeid,
+        });
+    }
+    handleForwardJump(targetStepIndex) {
+        // Validate intermediate steps (exclusive of target)
+        for (let i = this.activeTabIndex; i < targetStepIndex; i += 1) {
+            if (this.validation && this.validation[i]) {
+                if (!this.validation[i].isValid()) {
+                    this.tabs[i].completed = false;
+                    this.tabs[i].error = true;
+                    this.getCompletedTabs();
+                    this.$emit('validation-failure', {
+                        stepIndex: i,
+                        stepId: this.tabIds[i],
+                        message: `Validation failed for step ${i + 1}`,
+                    });
+                    return;
+                }
+                this.tabs[i].error = false;
             }
-            this.activetab = this.tabs[stepIndex];
-            this.activeid = this.tabIds[stepIndex];
-            this.$emit('step-click', {
-                activetab: this.activetab,
-                activeid: this.activeid,
-            });
         }
+        for (let i = this.activeTabIndex; i < targetStepIndex; i += 1) {
+            this.tabs[i].completed = true;
+            this.tabs[i].error = false;
+        }
+        this.tabs[targetStepIndex].completed = false;
+        this.tabs[targetStepIndex].error = false;
+        this.activeTabIndex = targetStepIndex;
+        this.activetab = this.tabs[targetStepIndex];
+        this.activeid = this.tabIds[targetStepIndex];
+        this.getCompletedTabs();
+        this.$emit('step-click', {
+            activetab: this.activetab,
+            activeid: this.activeid,
+        });
     }
     get disabledPreviousStep() {
         return this.activeTabIndex === 0 ? true : false;
@@ -153,7 +195,6 @@ export class Stepper extends FoundationElement {
     }
     nextStep() {
         var _a;
-        this.$emit('next-step');
         if (this.validation && this.validation[this.activeTabIndex]) {
             if (!this.validation[this.activeTabIndex].isValid()) {
                 this.tabs[this.activeTabIndex].completed = false;
@@ -167,6 +208,7 @@ export class Stepper extends FoundationElement {
             this.tabs[this.activeTabIndex].completed = true;
             this.activeTabIndex = this.activeTabIndex + 1;
             this.activeid = this.tabIds[this.activeTabIndex];
+            this.$emit('next-step');
             this.$emit('validation-success');
         }
         const lastStepIndex = this.tabs.length - 1;
@@ -216,6 +258,9 @@ __decorate([
 __decorate([
     attr({ attribute: 'allow-backward-jumps', mode: 'boolean' })
 ], Stepper.prototype, "allowBackwardJumps", void 0);
+__decorate([
+    attr({ attribute: 'allow-forward-jumps', mode: 'boolean' })
+], Stepper.prototype, "allowForwardJumps", void 0);
 __decorate([
     attr
 ], Stepper.prototype, "orientation", void 0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ui",
   "description": "Genesis Foundation UI",
-  "version": "14.304.3-alpha-586ff22.0",
+  "version": "14.306.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -83,13 +83,13 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/genx": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/rollup-builder": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/ts-builder": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/uvu-playwright-builder": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/vite-builder": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/webpack-builder": "14.304.3-alpha-586ff22.0",
+    "@genesislcap/foundation-testing": "14.306.0",
+    "@genesislcap/genx": "14.306.0",
+    "@genesislcap/rollup-builder": "14.306.0",
+    "@genesislcap/ts-builder": "14.306.0",
+    "@genesislcap/uvu-playwright-builder": "14.306.0",
+    "@genesislcap/vite-builder": "14.306.0",
+    "@genesislcap/webpack-builder": "14.306.0",
     "copyfiles": "^2.4.1",
     "rxjs": "^7.5.4"
   },
@@ -99,15 +99,15 @@
     "@fortawesome/free-regular-svg-icons": "^6.2.1",
     "@fortawesome/free-solid-svg-icons": "^6.2.1",
     "@genesiscommunitysuccess/analyzer-import-alias-plugin": "^5.0.3",
-    "@genesislcap/expression-builder": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-comms": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-criteria": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-errors": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-events": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-logger": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-notifications": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-user": "14.304.3-alpha-586ff22.0",
-    "@genesislcap/foundation-utils": "14.304.3-alpha-586ff22.0",
+    "@genesislcap/expression-builder": "14.306.0",
+    "@genesislcap/foundation-comms": "14.306.0",
+    "@genesislcap/foundation-criteria": "14.306.0",
+    "@genesislcap/foundation-errors": "14.306.0",
+    "@genesislcap/foundation-events": "14.306.0",
+    "@genesislcap/foundation-logger": "14.306.0",
+    "@genesislcap/foundation-notifications": "14.306.0",
+    "@genesislcap/foundation-user": "14.306.0",
+    "@genesislcap/foundation-utils": "14.306.0",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -128,5 +128,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "70fcabeff71f0fc646847a1a44baa80e694997ba"
+  "gitHead": "df5d88c4e8e25a56d2bf22dab70ca551784e6df0"
 }