Some useful updates

Significantly improved adventure compatibility

State made experimental; there's just one issue that's not noticeable to people and that is if State is done once, the key will never exist again

Author: coderFlameyosFlow

core/src/main/java/me/flame/menus/items/states/State.java

@@ -2,15 +2,17 @@
 
 import com.google.common.base.Preconditions;
 
+import me.flame.menus.adventure.Lore;
+import me.flame.menus.adventure.TextHolder;
 import me.flame.menus.items.MenuItem;
 
-import org.bukkit.Bukkit;
 import org.bukkit.inventory.ItemStack;
 
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.List;
 import java.util.function.DoubleSupplier;
 import java.util.function.IntSupplier;
 import java.util.function.LongSupplier;
@@ -29,12 +31,13 @@
  * @author FlameyosFlow
  * @since 2.0.0
  */
+@ApiStatus.Experimental
 public class State {
-    private final String key;
+    private final TextHolder key;
     private final MenuItem item;
-    private final Supplier<String> value;
+    private final Supplier<TextHolder> value;
 
-    private State(String key, Supplier<String> value, @NotNull MenuItem item) {
+    private State(TextHolder key, Supplier<TextHolder> value, @NotNull MenuItem item) {
         this.item = item;
 
         ItemStack stack = item.getItemStack();
@@ -51,38 +54,63 @@ private State(String key, Supplier<String> value, @NotNull MenuItem item) {
 
     @Contract(value = "_, _, _ -> new", pure = true)
     public static @NotNull State of(String key, String value, MenuItem item) {
-        return new State(key, () -> value, item);
+        return new State(TextHolder.of(key), () -> TextHolder.of(value), item);
     }
 
     @Contract(value = "_, _, _ -> new", pure = true)
     public static @NotNull State of(String key, IntSupplier value, MenuItem item) {
-        return new State(key, () -> String.valueOf(value.getAsInt()), item);
+        return new State(TextHolder.of(key), () -> TextHolder.of(String.valueOf(value.getAsInt())), item);
     }
 
     @Contract(value = "_, _, _ -> new", pure = true)
     public static @NotNull State of(String key, DoubleSupplier value, MenuItem item) {
-        return new State(key, () -> String.valueOf(value.getAsDouble()), item);
+        return new State(TextHolder.of(key), () -> TextHolder.of(String.valueOf(value.getAsDouble())), item);
     }
 
     @Contract(value = "_, _, _ -> new", pure = true)
     public static @NotNull State of(String key, LongSupplier value, MenuItem item) {
-        return new State(key, () -> String.valueOf(value.getAsLong()), item);
+        return new State(TextHolder.of(key), () -> TextHolder.of(String.valueOf(value.getAsLong())), item);
+    }
+
+    @Contract(value = "_, _, _ -> new", pure = true)
+    public static @NotNull State of(TextHolder key, String value, MenuItem item) {
+        return new State(key, () -> TextHolder.of(value), item);
+    }
+
+    @Contract(value = "_, _, _ -> new", pure = true)
+    public static @NotNull State of(TextHolder key, IntSupplier value, MenuItem item) {
+        return new State(key, () -> TextHolder.of(String.valueOf(value.getAsInt())), item);
+    }
+
+    @Contract(value = "_, _, _ -> new", pure = true)
+    public static @NotNull State of(TextHolder key, DoubleSupplier value, MenuItem item) {
+        return new State(key, () -> TextHolder.of(String.valueOf(value.getAsDouble())), item);
+    }
+
+    @Contract(value = "_, _, _ -> new", pure = true)
+    public static @NotNull State of(TextHolder key, LongSupplier value, MenuItem item) {
+        return new State(key, () -> TextHolder.of(String.valueOf(value.getAsLong())), item);
+    }
+
+    @Contract(value = "_, _, _ -> new", pure = true)
+    public static @NotNull State of(TextHolder key, TextHolder value, MenuItem item) {
+        return new State(key, () -> value, item);
     }
 
     @Contract(pure = true)
     public void update() {
         ItemStack otherItem = item.getItemStack();
-        List<String> list = Preconditions.checkNotNull(otherItem.getItemMeta()).getLore();
-        if (list == null) return;
+        ItemMeta meta = Preconditions.checkNotNull(otherItem.getItemMeta());
+        Lore lore = new Lore(meta);
 
-        int size = list.size();
-        for (int stringIndex = 0; stringIndex < size; stringIndex++) replaceWithKey(stringIndex, list);
-        item.editor().setLore(list).done();
+        int size = lore.size();
+        for (int stringIndex = 0; stringIndex < size; stringIndex++) replaceWithKey(stringIndex, lore, key, value);
+        lore.toItemLore(item.getItemStack());
     }
 
-    private void replaceWithKey(int stringIndex, @NotNull List<String> list) {
-        String currentString = list.get(stringIndex);
+    private static void replaceWithKey(int stringIndex, @NotNull Lore list, TextHolder key, Supplier<TextHolder> value) {
+        TextHolder currentString = list.get(stringIndex);
         if (!currentString.contains(key)) return;
-        list.set(stringIndex, currentString.replace(key, value.get()));
+        list.set(stringIndex, value.get());
     }
 }