DreamMessageFormatter.java

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 Dreamfire Studio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package com.dreamfirestudios.dreamcore.DreamChat;
 
import me.clip.placeholderapi.PlaceholderAPI;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
import java.util.Locale;
import java.util.Objects;
import java.util.regex.Pattern;
 
public final class DreamMessageFormatter {
 
    private DreamMessageFormatter() {}
 
    private static final MiniMessage MM = MiniMessage.miniMessage();
 
    // Basic scrubbers for when MiniMessage or specific tag families are disabled in settings
    private static final Pattern COLOR_TAGS = Pattern.compile(
            "</?#[0-9a-fA-F]{6}>|</?color(?:\\s*:\\s*#[0-9a-fA-F]{6})?>|</?gradient(?:\\s*:[^>]+)?>|</?rainbow(?:\\s*:[^>]+)?>"
    );
    private static final Pattern FORMAT_TAGS = Pattern.compile(
            "</?(bold|b|italic|i|underlined|u|strikethrough|st|obfuscated|obf)>"
    );
    private static final Pattern ACTION_TAGS = Pattern.compile(
            "</?click(?:\\s*:[^>]+)?>|</?hover(?:\\s*:[^>]+)?>"
    );
 
    // ---------------------------------------------------------------------
    // Public API — String -> Component
    // ---------------------------------------------------------------------
 
    public static @NotNull Component format(@Nullable String message,
                                            @Nullable DreamMessageSettings settings) {
        return format(message, null, settings);
    }
 
    public static @NotNull Component format(@Nullable String message,
                                            @Nullable Player player,
                                            @Nullable DreamMessageSettings settings,
                                            TagResolver... resolvers) {
        if (message == null) return Component.empty();
        final DreamMessageSettings s = nonNull(settings);
 
        String processed = message;
        if (s.usePlaceholders() && player != null && isPapiAvailable()) {
            processed = PlaceholderAPI.setPlaceholders(player, processed);
        }
 
        if (!s.allowMiniMessage()) {
            // Sanitization strips MiniMessage tags if disallowed; then emit as plain text.
            processed = sanitize(processed, s);
            return Component.text(processed);
        }
 
        processed = sanitize(processed, s);
        final TagResolver resolver = (resolvers != null && resolvers.length > 0)
                ? TagResolver.resolver(resolvers)
                : TagResolver.empty();
        return MM.deserialize(processed, resolver);
    }
 
    public static @NotNull Component format(@Nullable String message,
                                            @Nullable Player player,
                                            @Nullable DreamMessageSettings settings) {
        return format(message, player, settings, TagResolver.empty());
    }
 
    // ---------------------------------------------------------------------
    // Public API — Component -> Component
    // ---------------------------------------------------------------------
 
    public static @NotNull Component format(@Nullable Component component,
                                            @Nullable DreamMessageSettings settings) {
        return format(component, null, settings, TagResolver.empty());
    }
 
    public static @NotNull Component format(@Nullable Component component,
                                            @Nullable Player player,
                                            @Nullable DreamMessageSettings settings,
                                            TagResolver... resolvers) {
        if (component == null) return Component.empty();
        final DreamMessageSettings s = nonNull(settings);
 
        // If no MiniMessage or no placeholders are needed, return as-is (minor optimization).
        if (!s.allowMiniMessage() && !(s.usePlaceholders() && player != null && isPapiAvailable())) {
            return component;
        }
 
        // Serialize to MiniMessage so PAPI & sanitization operate on a string representation.
        String mm = MM.serialize(component);
 
        if (s.usePlaceholders() && player != null && isPapiAvailable()) {
            mm = PlaceholderAPI.setPlaceholders(player, mm);
        }
 
        mm = sanitize(mm, s);
 
        final TagResolver resolver = (resolvers != null && resolvers.length > 0)
                ? TagResolver.resolver(resolvers)
                : TagResolver.empty();
 
        return MM.deserialize(mm, resolver);
    }
 
    // ---------------------------------------------------------------------
    // Helpers — presentation utilities
    // ---------------------------------------------------------------------
 
    public static @Nullable String centerMessage(@Nullable String message, int width) {
        if (message == null) return null;
        final int w = Math.max(width, message.length());
        final int pad = w - message.length();
        final int left = pad / 2;
        final int right = pad - left;
        return " ".repeat(left) + message + " ".repeat(right);
        // For proportional fonts, consider pixel-width centering instead.
    }
 
    public static @NotNull Component centerMessage(@NotNull Component component, int width) {
        final String plain = PlainTextComponentSerializer.plainText().serialize(component);
        final String centered = centerMessage(plain, width);
        return Component.text(centered == null ? "" : centered);
    }
 
    public static @NotNull String limitMessage(@Nullable String message, int maxLen) {
        if (message == null || maxLen <= 0) return "...";
        if (message.length() <= maxLen) return message;
        return message.substring(0, Math.max(0, maxLen)) + "...";
    }
 
    public static @NotNull Component limitMessage(@NotNull Component component, int maxLen) {
        final String plain = PlainTextComponentSerializer.plainText().serialize(component);
        return Component.text(limitMessage(plain, maxLen));
    }
 
    public static @Nullable String capitalizeWords(@Nullable String message) {
        if (message == null || message.isEmpty()) return message;
        String[] words = message.split(" ");
        StringBuilder sb = new StringBuilder(message.length());
        for (String w : words) {
            if (w.isEmpty()) continue;
            sb.append(Character.toUpperCase(w.charAt(0)))
                    .append(w.substring(1).toLowerCase(Locale.ROOT))
                    .append(' ');
        }
        return sb.toString().trim();
    }
 
    public static @Nullable String reverseMessage(@Nullable String message) {
        if (message == null) return null;
        return new StringBuilder(message).reverse().toString();
    }
 
    // ---------------------------------------------------------------------
    // Placeholder helpers
    // ---------------------------------------------------------------------
 
    public static @NotNull TagResolver placeholder(@NotNull String key, @Nullable String value) {
        return Placeholder.unparsed(key, value == null ? "" : value);
    }
 
    public static @NotNull TagResolver placeholder(@NotNull String key, @NotNull Component value) {
        return Placeholder.component(key, value);
    }
 
    // ---------------------------------------------------------------------
    // Internals
    // ---------------------------------------------------------------------
 
    private static boolean isPapiAvailable() {
        return Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI");
    }
 
    private static @NotNull DreamMessageSettings nonNull(@Nullable DreamMessageSettings s) {
        return Objects.requireNonNullElse(s, DreamMessageSettings.all());
    }
 
    private static @NotNull String sanitize(@NotNull String input, @NotNull DreamMessageSettings s) {
        String out = input;
        if (!s.allowColors()) {
            out = COLOR_TAGS.matcher(out).replaceAll("");
        }
        if (!s.allowFormatting()) {
            out = FORMAT_TAGS.matcher(out).replaceAll("");
        }
        if (!s.allowClickAndHover()) {
            out = ACTION_TAGS.matcher(out).replaceAll("");
        }
        return out;
    }
}