refactor: replace two signals with a single GeolocationState sealed type

A single signal with a sealed type covering pending, position, and error
states enables exhaustive pattern matching and is more natural to consume
than separate value() and error() signals.

Author: Artur-

flow-server/src/main/java/com/vaadin/flow/component/geolocation/Geolocation.java

@@ -32,8 +32,8 @@
  * <ul>
  * <li>{@link #get(SerializableConsumer)} for a one-shot position request with
  * callbacks</li>
- * <li>{@link #track(Component)} for continuous position tracking via reactive
- * {@link Signal}s, automatically tied to the owner component's lifecycle</li>
+ * <li>{@link #track(Component)} for continuous position tracking via a reactive
+ * {@link Signal}, automatically tied to the owner component's lifecycle</li>
  * </ul>
  *
  * <p>
@@ -50,9 +50,12 @@
  * <pre>
  * Geolocation geo = Geolocation.track(this);
  * ComponentEffect.effect(this, () -&gt; {
- *     GeolocationPosition pos = geo.value().get();
- *     if (pos != null) {
+ *     switch (geo.state().get()) {
+ *     case GeolocationState.Pending p -&gt; {
+ *     }
+ *     case GeolocationPosition pos -&gt;
  *         map.setCenter(pos.coords().latitude(), pos.coords().longitude());
+ *     case GeolocationError err -&gt; showError(err.message());
  *     }
  * });
  * </pre>
@@ -67,8 +70,8 @@ private record GetResult(GeolocationPosition position,
             GeolocationError error) {
     }
 
-    private final ValueSignal<GeolocationPosition> positionSignal = new ValueSignal<>();
-    private final ValueSignal<GeolocationError> errorSignal = new ValueSignal<>();
+    private final ValueSignal<GeolocationState> stateSignal = new ValueSignal<>(
+            new GeolocationState.Pending());
 
     private Geolocation() {
     }
@@ -161,14 +164,15 @@ public static void get(GeolocationOptions options,
      * Starts continuous position tracking, tied to the owner component's
      * lifecycle.
      * <p>
-     * Position updates are available through {@link #value()} and errors
-     * through {@link #error()}. Tracking stops automatically when the owner
-     * component detaches.
+     * The tracking state is available through {@link #state()}, which starts as
+     * {@link GeolocationState.Pending} and transitions to
+     * {@link GeolocationPosition} or {@link GeolocationError} as the browser
+     * reports updates. Tracking stops automatically when the owner component
+     * detaches.
      *
      * @param owner
      *            the component whose lifecycle controls the tracking
-     * @return a {@link Geolocation} instance with reactive signals for position
-     *         and error
+     * @return a {@link Geolocation} instance with a reactive state signal
      */
     public static Geolocation track(Component owner) {
         return track(owner, null);
@@ -178,16 +182,17 @@ public static Geolocation track(Component owner) {
      * Starts continuous position tracking with the given options, tied to the
      * owner component's lifecycle.
      * <p>
-     * Position updates are available through {@link #value()} and errors
-     * through {@link #error()}. Tracking stops automatically when the owner
-     * component detaches.
+     * The tracking state is available through {@link #state()}, which starts as
+     * {@link GeolocationState.Pending} and transitions to
+     * {@link GeolocationPosition} or {@link GeolocationError} as the browser
+     * reports updates. Tracking stops automatically when the owner component
+     * detaches.
      *
      * @param owner
      *            the component whose lifecycle controls the tracking
      * @param options
      *            the geolocation options, or {@code null} for browser defaults
-     * @return a {@link Geolocation} instance with reactive signals for position
-     *         and error
+     * @return a {@link Geolocation} instance with a reactive state signal
      */
     public static Geolocation track(Component owner,
             GeolocationOptions options) {
@@ -196,14 +201,13 @@ public static Geolocation track(Component owner,
 
         DomListenerRegistration posReg = el
                 .addEventListener("vaadin-geolocation-position", e -> {
-                    geo.positionSignal
+                    geo.stateSignal
                             .set(e.getEventDetail(GeolocationPosition.class));
-                    geo.errorSignal.set(null);
                 }).addEventDetail().allowInert();
 
         DomListenerRegistration errReg = el
                 .addEventListener("vaadin-geolocation-error", e -> {
-                    geo.errorSignal
+                    geo.stateSignal
                             .set(e.getEventDetail(GeolocationError.class));
                 }).addEventDetail().allowInert();
 
@@ -222,24 +226,14 @@ public static Geolocation track(Component owner,
     }
 
     /**
-     * Returns a signal that holds the latest position received from the
-     * browser. The signal value is {@code null} until the first position update
-     * arrives.
-     *
-     * @return a read-only signal with the current position
-     */
-    public Signal<GeolocationPosition> value() {
-        return positionSignal;
-    }
-
-    /**
-     * Returns a signal that holds the latest error received from the browser,
-     * or {@code null} if no error has occurred or a successful position update
-     * has been received since the last error.
+     * Returns a signal holding the current tracking state. The signal starts as
+     * {@link GeolocationState.Pending} and transitions to
+     * {@link GeolocationPosition} or {@link GeolocationError} as the browser
+     * reports updates.
      *
-     * @return a read-only signal with the current error
+     * @return a read-only signal with the current geolocation state
      */
-    public Signal<GeolocationError> error() {
-        return errorSignal;
+    public Signal<GeolocationState> state() {
+        return stateSignal;
     }
 }

flow-server/src/main/java/com/vaadin/flow/component/geolocation/GeolocationError.java

@@ -24,7 +24,8 @@
  * @param message
  *            a human-readable error message
  */
-public record GeolocationError(int code, String message) {
+public record GeolocationError(int code,
+        String message) implements GeolocationState {
 
     /**
      * The user denied the request for geolocation.

flow-server/src/main/java/com/vaadin/flow/component/geolocation/GeolocationPosition.java

@@ -26,5 +26,5 @@
  *            since the Unix epoch
  */
 public record GeolocationPosition(GeolocationCoordinates coords,
-        long timestamp) {
+        long timestamp) implements GeolocationState {
 }

flow-server/src/main/java/com/vaadin/flow/component/geolocation/GeolocationState.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2000-2026 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.flow.component.geolocation;
+
+/**
+ * Represents the state of a geolocation tracking request.
+ * <p>
+ * Three states are possible:
+ * <ul>
+ * <li>{@link Pending} — initial state before the browser responds</li>
+ * <li>{@link GeolocationPosition} — a successful position fix</li>
+ * <li>{@link GeolocationError} — the browser reported an error</li>
+ * </ul>
+ * <p>
+ * The sealed type enables exhaustive pattern matching:
+ *
+ * <pre>
+ * switch (geo.state().get()) {
+ * case GeolocationState.Pending p -&gt; {
+ * }
+ * case GeolocationPosition pos -&gt; map.setCenter(pos.coords());
+ * case GeolocationError err -&gt; showError(err.message());
+ * }
+ * </pre>
+ */
+public sealed interface GeolocationState permits GeolocationState.Pending,
+        GeolocationPosition, GeolocationError {
+
+    /**
+     * Initial state before the browser has responded to the tracking request.
+     */
+    record Pending() implements GeolocationState {
+    }
+}

flow-server/src/test/java/com/vaadin/flow/component/geolocation/GeolocationTest.java

@@ -122,10 +122,9 @@ void track_registersListenersAndExecutesWatchJs() {
         Geolocation geo = Geolocation.track(component);
 
         Assertions.assertNotNull(geo);
-        Assertions.assertNotNull(geo.value());
-        Assertions.assertNotNull(geo.error());
-        Assertions.assertNull(geo.value().get());
-        Assertions.assertNull(geo.error().get());
+        Assertions.assertNotNull(geo.state());
+        Assertions.assertInstanceOf(GeolocationState.Pending.class,
+                geo.state().get());
 
         List<PendingJavaScriptInvocation> invocations = ui
                 .dumpPendingJsInvocations();
@@ -159,8 +158,9 @@ void track_signalUpdatesOnPositionEvent() {
         fireEvent(component.getElement(), "vaadin-geolocation-position",
                 eventData);
 
-        GeolocationPosition pos = geo.value().get();
-        Assertions.assertNotNull(pos);
+        Assertions.assertInstanceOf(GeolocationPosition.class,
+                geo.state().get());
+        GeolocationPosition pos = (GeolocationPosition) geo.state().get();
         Assertions.assertEquals(60.1699, pos.coords().latitude());
         Assertions.assertEquals(24.9384, pos.coords().longitude());
         Assertions.assertEquals(10.0, pos.coords().accuracy());
@@ -187,8 +187,8 @@ void track_signalUpdatesOnErrorEvent() {
         fireEvent(component.getElement(), "vaadin-geolocation-error",
                 eventData);
 
-        GeolocationError error = geo.error().get();
-        Assertions.assertNotNull(error);
+        Assertions.assertInstanceOf(GeolocationError.class, geo.state().get());
+        GeolocationError error = (GeolocationError) geo.state().get();
         Assertions.assertEquals(GeolocationError.PERMISSION_DENIED,
                 error.code());
         Assertions.assertEquals("User denied geolocation", error.message());
@@ -210,7 +210,7 @@ void track_errorClearedOnNewPosition() {
         fireEvent(component.getElement(), "vaadin-geolocation-error",
                 errEventData);
 
-        Assertions.assertNotNull(geo.error().get());
+        Assertions.assertInstanceOf(GeolocationError.class, geo.state().get());
 
         // Then simulate a successful position
         ObjectNode posEventData = JacksonUtils.createObjectNode();
@@ -225,8 +225,8 @@ void track_errorClearedOnNewPosition() {
         fireEvent(component.getElement(), "vaadin-geolocation-position",
                 posEventData);
 
-        Assertions.assertNull(geo.error().get());
-        Assertions.assertNotNull(geo.value().get());
+        Assertions.assertInstanceOf(GeolocationPosition.class,
+                geo.state().get());
     }
 
     @Test

flow-tests/test-root-context/src/main/java/com/vaadin/flow/uitest/ui/GeolocationView.java

@@ -17,6 +17,7 @@
 
 import com.vaadin.flow.component.UI;
 import com.vaadin.flow.component.geolocation.Geolocation;
+import com.vaadin.flow.component.geolocation.GeolocationPosition;
 import com.vaadin.flow.component.html.Div;
 import com.vaadin.flow.component.html.NativeButton;
 import com.vaadin.flow.router.Route;
@@ -81,8 +82,8 @@ protected void onShow() {
                     // a short delay via JS round-trip
                     UI.getCurrent().getPage().executeJs("return true")
                             .then(Boolean.class, ok -> {
-                                var pos = geo.value().get();
-                                if (pos != null) {
+                                if (geo.state()
+                                        .get() instanceof GeolocationPosition pos) {
                                     Div result = new Div();
                                     result.setId("trackResult");
                                     result.setText("lat="