bump to 1.2.6

Author: 404Setup

build.gradle.kts

@@ -37,12 +37,12 @@ dependencies {
     compileOnly("it.unimi.dsi:fastutil:8.5.15")
     implementation("com.google.code.gson:gson:2.12.1")
 
-    implementation("one.tranic:t-thread:1.0.0")
+    implementation("one.tranic:t-thread:1.0.1")
     implementation("one.tranic:t-proxy:1.0.0")
-    implementation("one.tranic:t-utils:1.2.1")
+    implementation("one.tranic:t-utils:1.2.2.1")
 
-    implementation("net.kyori:adventure-api:4.18.0")
-    implementation("net.kyori:adventure-text-minimessage:4.18.0")
+    implementation("net.kyori:adventure-api:4.19.0")
+    implementation("net.kyori:adventure-text-minimessage:4.19.0")
 }
 
 val targetJavaVersion = 17

src/main/java/one/tranic/t/base/TBase.java

@@ -12,15 +12,14 @@
 
 public class TBase {
     public final static ExecutorService executor = T2hread.getExecutor();
-    //public final static List<String> EMPTY_LIST = Collections.newUnmodifiableList();
-    public static final SystemCommandSource<?, ?> CONSOLE_SOURCE;
     private final static Operator operator = new Operator("Console", UUID.fromString("05b11eee-24db-4a21-ba9d-e12e8df9a92f"));
     private static final String packageName;
+    //public final static List<String> EMPTY_LIST = Collections.newUnmodifiableList();
+    private static SystemCommandSource<?, ?> CONSOLE_SOURCE;
     private static Supplier<SystemCommandSource<?, ?>> getConsoleSourceSupplier;
 
     static {
         packageName = getRootPath();
-        CONSOLE_SOURCE = getConsoleSource();
     }
 
     /**
@@ -64,8 +63,12 @@ public static Operator console() {
      * for administrative or automated command execution.
      */
     public static @Nullable SystemCommandSource<?, ?> getConsoleSource() {
-        if (getConsoleSourceSupplier == null) return null;
-        return getConsoleSourceSupplier.get();
+        if (CONSOLE_SOURCE != null) return CONSOLE_SOURCE;
+        if (getConsoleSourceSupplier != null) {
+            CONSOLE_SOURCE = getConsoleSourceSupplier.get();
+            return CONSOLE_SOURCE;
+        }
+        return null;
     }
 
     /**

src/main/java/one/tranic/t/base/cache/Cache.java

@@ -0,0 +1,19 @@
+package one.tranic.t.base.cache;
+
+/**
+ * Represents a generic cache interface that provides access
+ * to the underlying {@link CacheService} implementation.
+ * <p>
+ * Classes implementing this interface are responsible for
+ * defining specific cache behaviors while encapsulating their
+ * implementation details through the provided service.
+ */
+public interface Cache extends AutoCloseable {
+    /**
+     * Retrieves the underlying CacheService instance associated with the current Cache implementation.
+     * This method provides access to the internal caching service used for managing cache operations.
+     *
+     * @return the CacheService instance backing the current Cache implementation.
+     */
+    CacheService getService();
+}

src/main/java/one/tranic/t/base/cache/CacheService.java

@@ -0,0 +1,18 @@
+package one.tranic.t.base.cache;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Range;
+
+import java.util.Optional;
+
+public interface CacheService extends AutoCloseable {
+    <T> @NotNull Optional<T> get(@NotNull String key, @NotNull Class<T> type);
+
+    @NotNull String get(@NotNull String key);
+
+    void put(@NotNull String key, @NotNull Object value, @Range(from = 0, to = Long.MAX_VALUE) long ttl);
+
+    void invalidate(@NotNull String key);
+
+    void invalidateAll();
+}

src/main/java/one/tranic/t/base/command/simple/SimpleCommand.java

@@ -44,7 +44,7 @@ public void sendResult(C source, Component msg) {
      */
     public void sendResult(C source, Component msg, boolean withConsole) {
         if (source.isPlayer()) source.sendMessage(msg);
-        if (withConsole) TBase.CONSOLE_SOURCE.sendMessage(msg);
+        if (withConsole) TBase.getConsoleSource().sendMessage(msg);
     }
 
     /**
@@ -66,7 +66,7 @@ public void sendResult(C source, String msg) {
      */
     public void sendResult(C source, String msg, boolean withConsole) {
         if (source.isPlayer()) source.sendMessage(msg);
-        if (withConsole) TBase.CONSOLE_SOURCE.sendMessage(msg);
+        if (withConsole) TBase.getConsoleSource().sendMessage(msg);
     }
 
     /**

src/main/java/one/tranic/t/base/exception/CommandException.java

@@ -3,14 +3,6 @@
 /**
  * A custom exception that represents errors occurring during the execution
  * or processing of commands in the application.
- * <p>
- * This exception is a subclass of {@code RuntimeException} and is designed to signal command-specific failures
- * that developers or users need to be made aware of.
- * <p>
- * This exception can be used in scenarios where command validation, execution,
- * or configuration fails or encounters issues.
- * <p>
- * Developers can provide additional details about the failure by using the constructor that accepts a message.
  */
 public class CommandException extends RuntimeException {
     public CommandException(String message) {

src/main/java/one/tranic/t/base/exception/ConnectionTestFailedException.java

@@ -0,0 +1,15 @@
+package one.tranic.t.base.exception;
+
+public class ConnectionTestFailedException extends RuntimeException {
+    public ConnectionTestFailedException() {
+        super();
+    }
+
+    public ConnectionTestFailedException(String message) {
+        super(message);
+    }
+
+    public ConnectionTestFailedException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/one/tranic/t/base/exception/UnsupportedTypeException.java

@@ -2,12 +2,6 @@
 
 /**
  * A custom exception that indicates an operation involving an unsupported or invalid type.
- * <p>
- * This exception is a subclass of {@code RuntimeException} and is typically used to signal
- * situations where a type provided to a method or operation is invalid or not supported.
- * <p>
- * This exception can be constructed with a custom message, an existing exception, or
- * automatically include the class name of the unsupported object to provide additional context.
  */
 public class UnsupportedTypeException extends RuntimeException {
     /**

src/main/java/one/tranic/t/base/parse/mojang/MojangAPIParser.java

@@ -10,6 +10,8 @@
 import java.io.OutputStream;
 import java.lang.reflect.Type;
 import java.net.HttpURLConnection;
+import java.net.Proxy;
+import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.UUID;
@@ -20,55 +22,114 @@
  * Connections are established using the RequestWithProxyParser class to support proxy configurations.
  */
 public class MojangAPIParser {
-
     private static final String BASE_URL = "https://api.minecraftservices.com/minecraft/profile/lookup";
+    private static final String NAME_ENDPOINT = "/name/";
+    private static final String BULK_ENDPOINT = "/bulk/byname";
+    private static final String CONTENT_TYPE = "Content-Type";
+    private static final String APPLICATION_JSON = "application/json";
+    private static final String POST_METHOD = "POST";
 
     /**
-     * Looks up a Minecraft profile by its username using the Mojang API.
+     * Retrieves the profile information for a user based on their username.
      *
-     * @param name the username of the Minecraft profile to be looked up
-     * @return a {@code ProfileLookup} object containing the profile's ID and username
-     * @throws IOException if an I/O error occurs while connecting to the Mojang API or parsing the response
+     * @param name the username for which profile information is to be looked up
+     * @return a {@link ProfileLookup} object containing the profile information
+     * @throws IOException if an I/O error occurs during the profile lookup
      */
     public static ProfileLookup lookupProfile(String name) throws IOException {
-        String url = BASE_URL + "/name/" + name;
-        HttpURLConnection connection = RequestWithProxyParser.openConnection(url);
+        return lookupProfile(true, name);
+    }
+
+    /**
+     * Looks up profile information for a given username from a remote server.
+     *
+     * @param useProxy whether to use a proxy connection for the request
+     * @param name     the username to look up
+     * @return the {@link ProfileLookup} containing the profile ID and name
+     * @throws IOException if an I/O error occurs while performing the request or reading the response
+     */
+    public static ProfileLookup lookupProfile(boolean useProxy, String name) throws IOException {
+        String url = BASE_URL + NAME_ENDPOINT + name;
+        HttpURLConnection connection = createConnection(url, useProxy);
         return JsonParser.requestAndParse(connection, ProfileLookup.class);
     }
 
     /**
-     * Retrieves the Minecraft profile associated with the given UUID by performing a lookup request to the Mojang API.
+     * Retrieves the profile information associated with the specified UUID.
      *
-     * @param uuid the unique identifier of the Minecraft account to look up, must not be null
-     * @return a {@link ProfileLookup} record containing the profile information, including the UUID and username
-     * @throws IOException if an I/O error occurs while making the request or parsing the response
+     * @param uuid the {@link UUID} of the profile to lookup; must not be null
+     * @return a {@link ProfileLookup} containing the profile information corresponding to the given UUID
+     * @throws IOException if an I/O error occurs while making the request or processing the response
      */
     public static ProfileLookup lookupProfile(UUID uuid) throws IOException {
+        return lookupProfile(true, uuid);
+    }
+
+    /**
+     * Looks up a profile from the Mojang API using the specified UUID.
+     *
+     * @param useProxy a boolean indicating whether a proxy should be used for the connection
+     * @param uuid     the UUID of the profile to lookup, must not be null
+     * @return a {@link ProfileLookup} object containing the profile information
+     * @throws IOException if an error occurs during the network request or while reading the response
+     */
+    public static ProfileLookup lookupProfile(boolean useProxy, UUID uuid) throws IOException {
         String url = BASE_URL + "/" + UUIDParser.removeDashes(uuid);
-        HttpURLConnection connection = RequestWithProxyParser.openConnection(url);
+        HttpURLConnection connection = createConnection(url, useProxy);
         return JsonParser.requestAndParse(connection, ProfileLookup.class);
     }
 
     /**
-     * Retrieves a list of Minecraft profiles by performing a bulk lookup using an array of usernames.
+     * Retrieves a list of profile lookups for the given player names.
+     *
+     * @param names the array of player names to look up profiles for; each name must be a valid string
+     * @return a list of {@code ProfileLookup} records containing the ID and name of each requested profile
+     * @throws IOException if an I/O error occurs during the HTTP request or response parsing
+     */
+    public static List<ProfileLookup> lookupProfiles(String... names) throws IOException {
+        return lookupProfiles(true, names);
+    }
+
+    /**
+     * Looks up profiles for the given list of names by sending an HTTP request to the Mojang API.
      *
-     * @param names an array of usernames to be looked up; each name represents a Minecraft user's profile
-     * @return a list of {@code ProfileLookup} records containing the id and name of the queried profiles
-     * @throws IOException if an I/O error occurs during the HTTP request or response handling
+     * @param useProxy a boolean indicating whether to use a proxy for the HTTP connection
+     * @param names    a variable-length list of usernames to look up profiles for
+     * @return a list of {@link ProfileLookup} representing the fetched profile information for each provided name
+     * @throws IOException if an I/O error occurs while making the request or processing the response
      */
-    public static List<ProfileLookup> lookupProfile(String... names) throws IOException {
-        String url = BASE_URL + "/bulk/byname";
-        HttpURLConnection connection = RequestWithProxyParser.openConnection(url);
-        connection.setRequestMethod("POST");
-        connection.setRequestProperty("Content-Type", "application/json");
+    public static List<ProfileLookup> lookupProfiles(boolean useProxy, String... names) throws IOException {
+        String url = BASE_URL + BULK_ENDPOINT;
+        HttpURLConnection connection = createConnection(url, useProxy);
+
+        connection.setRequestMethod(POST_METHOD);
+        connection.setRequestProperty(CONTENT_TYPE, APPLICATION_JSON);
         connection.setDoOutput(true);
+
         String jsonBody = JsonParser.toJson(names);
         try (OutputStream outputStream = connection.getOutputStream()) {
             outputStream.write(jsonBody.getBytes(StandardCharsets.UTF_8));
             outputStream.flush();
         }
+
         Type listType = new TypeToken<List<ProfileLookup>>() {
         }.getType();
         return JsonParser.requestAndParse(connection, listType);
     }
+
+    /**
+     * Creates and returns an {@link HttpURLConnection} instance for the specified URL.
+     * If the {@code useProxy} flag is set to {@code true}, a connection using a proxy is created.
+     * Otherwise, a direct connection is instantiated.
+     *
+     * @param url      the URL to which the connection is to be established
+     * @param useProxy a boolean flag indicating whether a proxy should be used for the connection
+     * @return an instance of {@link HttpURLConnection} configured based on the provided parameters
+     * @throws IOException if an I/O error occurs while creating the connection
+     */
+    private static HttpURLConnection createConnection(String url, boolean useProxy) throws IOException {
+        return useProxy
+                ? RequestWithProxyParser.openConnection(url)
+                : (HttpURLConnection) new URL(url).openConnection(Proxy.NO_PROXY);
+    }
 }

src/main/java/one/tranic/t/base/parse/network/NetworkParser.java renamed to src/main/java/one/tranic/t/base/parse/resource/ResourceParser.java

@@ -1,4 +1,4 @@
-package one.tranic.t.base.parse.network;
+package one.tranic.t.base.parse.resource;
 
 import com.google.common.io.Resources;
 import org.jetbrains.annotations.NotNull;
@@ -8,7 +8,7 @@
 import java.net.URL;
 import java.net.URLConnection;
 
-public class NetworkParser {
+public class ResourceParser {
     /**
      * Retrieves an InputStream for a specified resource file by its filename.
      *