style: apply code formatter

Author: javier-godoy

src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationJacksonHelper.java

@@ -7,9 +7,9 @@
  * 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.
@@ -51,5 +51,4 @@ public static String getConvertedTypeDescriptor(Class<?> type) {
     }
     return Type.getDescriptor(type);
   }
-
 }

src/main/java/com/flowingcode/vaadin/jsonmigration/ClassInstrumentationUtil.java

@@ -54,6 +54,4 @@ private static List<JsonNode> children(JsonArray a) {
   public JsonType getType() {
     return JsonType.ARRAY;
   }
-
 }
-

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalArrayNode.java

@@ -33,12 +33,4 @@ public ElementalBooleanNode(boolean value) {
   public JsonType getType() {
     return JsonType.BOOLEAN;
   }
-
 }
-
-
-
-
-
-
-

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalBooleanNode.java

@@ -38,6 +38,4 @@ public String toJson() {
   public JsonType getType() {
     return JsonType.NULL;
   }
-
 }
-

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalNullNode.java

@@ -43,6 +43,4 @@ public String toJson() {
   public JsonType getType() {
     return JsonType.NUMBER;
   }
-
 }
-

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalNumberNode.java

@@ -20,6 +20,7 @@
 package com.flowingcode.vaadin.jsonmigration;
 
 import static com.flowingcode.vaadin.jsonmigration.JsonMigrationHelper25.convertToJsonNode;
+
 import elemental.json.JsonObject;
 import elemental.json.JsonType;
 import java.util.Collections;
@@ -56,7 +57,4 @@ private static Map<String, JsonNode> children(JsonObject o) {
   public JsonType getType() {
     return JsonType.OBJECT;
   }
-
 }
-
-

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalObjectNode.java

@@ -18,6 +18,7 @@
  * #L%
  */
 package com.flowingcode.vaadin.jsonmigration;
+
 /*
  * Copyright 2000-2025 Vaadin Ltd.
  *
@@ -51,132 +52,107 @@
  */
 public interface ElementalPendingJavaScriptResult extends Serializable {
 
-    /**
-     * Adds an untyped handler that will be run for a successful execution and a
-     * handler that will be run for a failed execution. One of the handlers will
-     * be invoked asynchronously when the result of the execution is sent back
-     * to the server. It is not possible to synchronously wait for the result of
-     * the execution while holding the session lock since the request handling
-     * thread that makes the result available will also need to lock the
-     * session.
-     * <p>
-     * Handlers can only be added before the execution has been sent to the
-     * browser.
-     *
-     * @param resultHandler
-     *            a handler for the JSON representation of the value from a
-     *            successful execution, not <code>null</code>
-     * @param errorHandler
-     *            a handler for an error message in case the execution failed,
-     *            or <code>null</code> to ignore errors
-     */
-    void then(SerializableConsumer<JsonValue> resultHandler,
-            SerializableConsumer<String> errorHandler);
-
-    /**
-     * Adds an untyped handler that will be run for a successful execution. The
-     * handler will be invoked asynchronously if the execution was successful.
-     * In case of a failure, no handler will be run.
-     * <p>
-     * A handler can only be added before the execution has been sent to the
-     * browser.
-     *
-     * @param resultHandler
-     *            a handler for the JSON representation of the return value from
-     *            a successful execution, not <code>null</code>
-     */
-    default void then(SerializableConsumer<JsonValue> resultHandler) {
-        then(resultHandler, null);
-    }
-
-    /**
-     * Adds a typed handler that will be run for a successful execution and a
-     * handler that will be run for a failed execution. One of the handlers will
-     * be invoked asynchronously when the result of the execution is sent back
-     * to the server.
-     * <p>
-     * Handlers can only be added before the execution has been sent to the
-     * browser.
-     *
-     * @param targetType
-     *            the type to convert the JavaScript return value to, not
-     *            <code>null</code>
-     * @param resultHandler
-     *            a handler for the return value from a successful execution,
-     *            not <code>null</code>
-     * @param errorHandler
-     *            a handler for an error message in case the execution failed,
-     *            or <code>null</code> to ignore errors
-     */
-    default <T> void then(Class<T> targetType,
-            SerializableConsumer<T> resultHandler,
-            SerializableConsumer<String> errorHandler) {
-        if (targetType == null) {
-            throw new IllegalArgumentException("Target type cannot be null");
-        }
-        if (resultHandler == null) {
-            throw new IllegalArgumentException("Result handler cannot be null");
-        }
+  /**
+   * Adds an untyped handler that will be run for a successful execution and a handler that will be
+   * run for a failed execution. One of the handlers will be invoked asynchronously when the result
+   * of the execution is sent back to the server. It is not possible to synchronously wait for the
+   * result of the execution while holding the session lock since the request handling thread that
+   * makes the result available will also need to lock the session.
+   *
+   * <p>Handlers can only be added before the execution has been sent to the browser.
+   *
+   * @param resultHandler a handler for the JSON representation of the value from a successful
+   *     execution, not <code>null</code>
+   * @param errorHandler a handler for an error message in case the execution failed, or <code>null
+   *     </code> to ignore errors
+   */
+  void then(
+      SerializableConsumer<JsonValue> resultHandler, SerializableConsumer<String> errorHandler);
 
-        SerializableConsumer<JsonValue> convertingResultHandler = value -> resultHandler
-                .accept(JsonCodec.decodeAs(value, targetType));
+  /**
+   * Adds an untyped handler that will be run for a successful execution. The handler will be
+   * invoked asynchronously if the execution was successful. In case of a failure, no handler will
+   * be run.
+   *
+   * <p>A handler can only be added before the execution has been sent to the browser.
+   *
+   * @param resultHandler a handler for the JSON representation of the return value from a
+   *     successful execution, not <code>null</code>
+   */
+  default void then(SerializableConsumer<JsonValue> resultHandler) {
+    then(resultHandler, null);
+  }
 
-        then(convertingResultHandler, errorHandler);
+  /**
+   * Adds a typed handler that will be run for a successful execution and a handler that will be run
+   * for a failed execution. One of the handlers will be invoked asynchronously when the result of
+   * the execution is sent back to the server.
+   *
+   * <p>Handlers can only be added before the execution has been sent to the browser.
+   *
+   * @param targetType the type to convert the JavaScript return value to, not <code>null</code>
+   * @param resultHandler a handler for the return value from a successful execution, not <code>null
+   *     </code>
+   * @param errorHandler a handler for an error message in case the execution failed, or <code>null
+   *     </code> to ignore errors
+   */
+  default <T> void then(
+      Class<T> targetType,
+      SerializableConsumer<T> resultHandler,
+      SerializableConsumer<String> errorHandler) {
+    if (targetType == null) {
+      throw new IllegalArgumentException("Target type cannot be null");
     }
-
-    /**
-     * Adds a typed handler that will be run for a successful execution. The
-     * handler will be invoked asynchronously if the execution was successful.
-     * In case of a failure, no handler will be run.
-     * <p>
-     * A handler can only be added before the execution has been sent to the
-     * browser.
-     *
-     * @param targetType
-     *            the type to convert the JavaScript return value to, not
-     *            <code>null</code>
-     * @param resultHandler
-     *            a handler for the return value from a successful execution,
-     *            not <code>null</code>
-     */
-    default <T> void then(Class<T> targetType,
-            SerializableConsumer<T> resultHandler) {
-        then(targetType, resultHandler, null);
+    if (resultHandler == null) {
+      throw new IllegalArgumentException("Result handler cannot be null");
     }
 
-    /**
-     * Creates a typed completable future that will be completed with the result
-     * of the execution. It will be completed asynchronously when the result of
-     * the execution is sent back to the server. It is not possible to
-     * synchronously wait for the result of the execution while holding the
-     * session lock since the request handling thread that makes the result
-     * available will also need to lock the session.
-     * <p>
-     * A completable future can only be created before the execution has been
-     * sent to the browser.
-     *
-     * @param targetType
-     *            the type to convert the JavaScript return value to, not
-     *            <code>null</code>
-     *
-     * @return a completable future that will be completed based on the
-     *         execution results, not <code>null</code>
-     */
-    <T> CompletableFuture<T> toCompletableFuture(Class<T> targetType);
+    SerializableConsumer<JsonValue> convertingResultHandler =
+        value -> resultHandler.accept(JsonCodec.decodeAs(value, targetType));
 
-    /**
-     * Creates an untyped completable future that will be completed with the
-     * result of the execution. It will be completed asynchronously when the
-     * result of the execution is sent back to the server.
-     * <p>
-     * A completable future can only be created before the execution has been
-     * sent to the browser.
-     *
-     * @return a completable future that will be completed based on the
-     *         execution results, not <code>null</code>
-     */
-    default CompletableFuture<JsonValue> toCompletableFuture() {
-        return toCompletableFuture(JsonValue.class);
-    }
+    then(convertingResultHandler, errorHandler);
+  }
+
+  /**
+   * Adds a typed handler that will be run for a successful execution. The handler will be invoked
+   * asynchronously if the execution was successful. In case of a failure, no handler will be run.
+   *
+   * <p>A handler can only be added before the execution has been sent to the browser.
+   *
+   * @param targetType the type to convert the JavaScript return value to, not <code>null</code>
+   * @param resultHandler a handler for the return value from a successful execution, not <code>null
+   *     </code>
+   */
+  default <T> void then(Class<T> targetType, SerializableConsumer<T> resultHandler) {
+    then(targetType, resultHandler, null);
+  }
+
+  /**
+   * Creates a typed completable future that will be completed with the result of the execution. It
+   * will be completed asynchronously when the result of the execution is sent back to the server.
+   * It is not possible to synchronously wait for the result of the execution while holding the
+   * session lock since the request handling thread that makes the result available will also need
+   * to lock the session.
+   *
+   * <p>A completable future can only be created before the execution has been sent to the browser.
+   *
+   * @param targetType the type to convert the JavaScript return value to, not <code>null</code>
+   * @return a completable future that will be completed based on the execution results, not <code>
+   *     null</code>
+   */
+  <T> CompletableFuture<T> toCompletableFuture(Class<T> targetType);
 
+  /**
+   * Creates an untyped completable future that will be completed with the result of the execution.
+   * It will be completed asynchronously when the result of the execution is sent back to the
+   * server.
+   *
+   * <p>A completable future can only be created before the execution has been sent to the browser.
+   *
+   * @return a completable future that will be completed based on the execution results, not <code>
+   *     null</code>
+   */
+  default CompletableFuture<JsonValue> toCompletableFuture() {
+    return toCompletableFuture(JsonValue.class);
+  }
 }

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalPendingJavaScriptResult.java

@@ -33,5 +33,4 @@ public ElementalStringNode(String value) {
   public JsonType getType() {
     return JsonType.STRING;
   }
-
-}
+}

src/main/java/com/flowingcode/vaadin/jsonmigration/ElementalStringNode.java

@@ -25,8 +25,8 @@
 
 /**
  * Abstract base class for Vaadin service initializers that register instrumented views. Subclasses
- * should implement {@link #serviceInit(com.vaadin.flow.server.ServiceInitEvent)} and call
- * {@link #registerInstrumentedRoute(Class)} to register views with instrumented routes.
+ * should implement {@link #serviceInit(com.vaadin.flow.server.ServiceInitEvent)} and call {@link
+ * #registerInstrumentedRoute(Class)} to register views with instrumented routes.
  *
  * @author Javier Godoy / Flowing Code
  */
@@ -35,26 +35,26 @@ public abstract class InstrumentationViewInitializer implements VaadinServiceIni
 
   /**
    * Registers an instrumented route for the given navigation target. The navigation target must be
-   * annotated with {@link InstrumentedRoute} to specify the route path. This method calls
-   * {@link JsonMigration#instrumentClass(Class)} to get the instrumented class and registers it as
-   * a Vaadin view with the route derived from the annotation.
+   * annotated with {@link InstrumentedRoute} to specify the route path. This method calls {@link
+   * JsonMigration#instrumentClass(Class)} to get the instrumented class and registers it as a
+   * Vaadin view with the route derived from the annotation.
    *
    * @param navigationTarget the component class to instrument and register, must be annotated with
-   *        {@link InstrumentedRoute}
-   * @throws IllegalArgumentException if the navigationTarget is not annotated with
-   *         {@link InstrumentedRoute}
+   *     {@link InstrumentedRoute}
+   * @throws IllegalArgumentException if the navigationTarget is not annotated with {@link
+   *     InstrumentedRoute}
    */
   protected final void registerInstrumentedRoute(Class<? extends Component> navigationTarget) {
     InstrumentedRoute annotation = navigationTarget.getAnnotation(InstrumentedRoute.class);
     if (annotation == null) {
       throw new IllegalArgumentException(
-          navigationTarget.getName() + " must be annotated with @"
+          navigationTarget.getName()
+              + " must be annotated with @"
               + InstrumentedRoute.class.getSimpleName());
     }
 
     String route = annotation.value();
     navigationTarget = JsonMigration.instrumentClass(navigationTarget);
     RouteConfiguration.forApplicationScope().setRoute(route, navigationTarget);
   }
-
 }