feat(item): 优化PreparedItem的结构，使其适用于更多项目。

Bumps [com.github.cryptomorin:XSeries](https://github.com/CryptoMorin/XSeries) from 9.6.0 to 9.6.1.1.
- [Release notes](https://github.com/CryptoMorin/XSeries/releases)
- [Commits](https://github.com/CryptoMorin/XSeries/compare/v9.6.0...v9.6.1.1)

---
updated-dependencies:
- dependency-name: com.github.cryptomorin:XSeries
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/deploy.yml

@@ -22,7 +22,7 @@ jobs:
         with:
           java-version: '11'
           distribution: 'adopt'
-          cache: maven
+#          cache: maven  # Say 4uck u to github cache services.
           server-id: github
           server-username: MAVEN_USERNAME
           server-password: MAVEN_TOKEN
@@ -46,7 +46,7 @@ jobs:
         with:
           java-version: '11'
           distribution: 'adopt'
-          cache: maven
+#          cache: maven  # Say 4uck u to github cache services.
           server-id: ossrh
           server-username: MAVEN_USERNAME
           server-password: MAVEN_PASSWORD

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>mineconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>2.8.2</version>
+        <version>2.8.7</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <properties>

platform/bukkit/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>mineconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>2.8.2</version>
+        <version>2.8.7</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
@@ -40,7 +40,7 @@
         <dependency>
             <groupId>com.github.cryptomorin</groupId>
             <artifactId>XSeries</artifactId>
-            <version>9.5.0</version>
+            <version>9.6.1.1</version>
             <scope>compile</scope>
         </dependency>
 
@@ -56,7 +56,7 @@
         <dependency>
             <groupId>me.clip</groupId>
             <artifactId>placeholderapi</artifactId>
-            <version>2.11.3</version>
+            <version>2.11.4</version>
             <scope>provided</scope>
         </dependency>
 

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/builder/item/ItemConfigBuilder.java

@@ -2,7 +2,7 @@ package cc.carm.lib.mineconfiguration.bukkit.builder.item;
 
 import cc.carm.lib.configuration.core.value.ValueManifest;
 import cc.carm.lib.mineconfiguration.bukkit.builder.AbstractCraftBuilder;
-import cc.carm.lib.mineconfiguration.bukkit.value.ConfiguredItem;
+import cc.carm.lib.mineconfiguration.bukkit.value.item.ConfiguredItem;
 import cc.carm.lib.mineconfiguration.common.utils.ParamsUtils;
 import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/data/ItemConfig.java

@@ -1,180 +0,0 @@
-package cc.carm.lib.mineconfiguration.bukkit.data;
-
-import cc.carm.lib.configuration.core.source.ConfigurationWrapper;
-import cc.carm.lib.mineconfiguration.bukkit.source.CraftSectionWrapper;
-import cc.carm.lib.mineconfiguration.bukkit.utils.TextParser;
-import org.bukkit.Material;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemFlag;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class ItemConfig {
-
-    protected @NotNull Material type;
-    protected short data;
-    protected @Nullable String name;
-    protected @NotNull List<String> lore;
-
-    protected @NotNull Map<Enchantment, Integer> enchants;
-    protected @NotNull Set<ItemFlag> flags;
-
-    protected int customModelData = 0;
-
-    public ItemConfig(@NotNull Material type, @Nullable String name) {
-        this(type, name, Collections.emptyList());
-    }
-
-    public ItemConfig(@NotNull Material type, @Nullable String name, @NotNull List<String> lore) {
-        this(type, (short) 0, name, lore);
-    }
-
-    public ItemConfig(@NotNull Material type, short damage,
-                      @Nullable String name, @NotNull List<String> lore) {
-        this(type, damage, name, lore, Collections.emptyMap(), Collections.emptySet());
-    }
-
-    public ItemConfig(@NotNull Material type, short damage,
-                      @Nullable String name, @NotNull List<String> lore,
-                      @NotNull Map<Enchantment, Integer> enchants,
-                      @NotNull Set<ItemFlag> flags) {
-        this.type = type;
-        this.data = damage;
-        this.name = name;
-        this.lore = lore;
-        this.enchants = enchants;
-        this.flags = flags;
-    }
-
-    public @NotNull Material getType() {
-        return type;
-    }
-
-    public short getData() {
-        return data;
-    }
-
-    public @Nullable String getName() {
-        return name;
-    }
-
-    public @Nullable String getName(@Nullable Player player, @NotNull Map<String, Object> placeholders) {
-        return Optional.ofNullable(getName())
-                .map(name -> TextParser.parseText(player, name, placeholders))
-                .orElse(null);
-    }
-
-    public @NotNull List<String> getLore() {
-        return lore;
-    }
-
-    public @Nullable List<String> getLore(@Nullable Player player, @NotNull Map<String, Object> placeholders) {
-        if (getLore().isEmpty()) return null;
-        else return TextParser.parseList(player, getLore(), placeholders);
-    }
-
-    public final @NotNull ItemStack getItemStack() {
-        return getItemStack(1);
-    }
-
-    public @NotNull ItemStack getItemStack(int amount) {
-        return getItemStack(null, amount, new HashMap<>());
-    }
-
-    public @NotNull ItemStack getItemStack(@Nullable Player player) {
-        return getItemStack(player, new HashMap<>());
-    }
-
-    public @NotNull ItemStack getItemStack(@Nullable Player player, @NotNull Map<String, Object> placeholders) {
-        return getItemStack(player, 1, placeholders);
-    }
-
-    public @NotNull ItemStack getItemStack(@Nullable Player player, int amount, @NotNull Map<String, Object> placeholders) {
-        ItemStack item = new ItemStack(type, amount, data);
-        ItemMeta meta = item.getItemMeta();
-        if (meta == null) return item;
-        Optional.ofNullable(getName(player, placeholders)).ifPresent(meta::setDisplayName);
-        Optional.ofNullable(getLore(player, placeholders)).ifPresent(meta::setLore);
-        enchants.forEach((enchant, level) -> meta.addEnchant(enchant, level, true));
-        flags.forEach(meta::addItemFlags);
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    public @NotNull Map<String, Object> serialize() {
-        Map<String, Object> map = new LinkedHashMap<>();
-        map.put("type", type.name());
-        if (this.data != 0) map.put("data", data);
-        if (name != null) map.put("name", name);
-        if (!lore.isEmpty()) map.put("lore", lore);
-
-        Map<String, Integer> enchantments = new LinkedHashMap<>();
-        enchants.forEach((enchant, level) -> {
-            if (level > 0) enchantments.put(enchant.getName(), level);
-        });
-
-        if (!enchantments.isEmpty()) {
-            map.put("enchants", enchantments);
-        }
-
-        if (!flags.isEmpty()) {
-            map.put("flags", flags.stream().map(ItemFlag::name).collect(Collectors.toList()));
-        }
-        return map;
-    }
-
-    public static @NotNull ItemConfig deserialize(@NotNull ConfigurationSection section) throws Exception {
-        return deserialize(CraftSectionWrapper.of(section));
-    }
-
-    public static @NotNull ItemConfig deserialize(@NotNull ConfigurationWrapper<?> section) throws Exception {
-        String typeName = section.getString("type");
-        if (typeName == null) throw new NullPointerException("Item type name is null");
-
-        Material type = Material.matchMaterial(typeName);
-        if (type == null) throw new Exception("Invalid material name: " + typeName);
-
-        short data = section.getShort("data", (short) 0);
-        String name = section.getString("name");
-        List<String> lore = section.getStringList("lore");
-
-        Map<Enchantment, Integer> enchantments = readEnchantments(section.getConfigurationSection("enchants"));
-        Set<ItemFlag> flags = readFlags(section.getStringList("flags"));
-
-        return new ItemConfig(type, data, name, lore, enchantments, flags);
-    }
-
-    private static ItemFlag parseFlag(String flagName) {
-        return Arrays.stream(ItemFlag.values()).filter(flag -> flag.name().equalsIgnoreCase(flagName)).findFirst().orElse(null);
-    }
-
-    private static Set<ItemFlag> readFlags(List<String> flagConfig) {
-        Set<ItemFlag> flags = new LinkedHashSet<>();
-        for (String flagName : flagConfig) {
-            ItemFlag flag = parseFlag(flagName);
-            if (flag != null) flags.add(flag);
-        }
-        return flags;
-    }
-
-    private static Map<Enchantment, Integer> readEnchantments(ConfigurationWrapper<?> section) {
-        Map<Enchantment, Integer> enchantments = new LinkedHashMap<>();
-        if (section == null) return enchantments;
-        section.getKeys(false).forEach(key -> {
-            Enchantment enchantment = Enchantment.getByName(key);
-            int level = section.getInt(key, 0);
-            if (enchantment != null && level > 0) {
-                enchantments.put(enchantment, level);
-            }
-        });
-        return enchantments;
-    }
-
-}

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/value/ConfiguredItem.java

@@ -1,252 +0,0 @@
-package cc.carm.lib.mineconfiguration.bukkit.value;
-
-import cc.carm.lib.configuration.core.value.ValueManifest;
-import cc.carm.lib.configuration.core.value.type.ConfiguredList;
-import cc.carm.lib.configuration.core.value.type.ConfiguredSection;
-import cc.carm.lib.mineconfiguration.bukkit.builder.item.ItemConfigBuilder;
-import cc.carm.lib.mineconfiguration.bukkit.utils.TextParser;
-import cc.carm.lib.mineconfiguration.common.utils.ParamsUtils;
-import com.cryptomorin.xseries.XItemStack;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemFlag;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.*;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class ConfiguredItem extends ConfiguredSection<ItemStack> {
-
-    public static final @NotNull Pattern LORE_INSERT_PATTERN = Pattern.compile("^#(.*)#$");
-
-    public static ItemConfigBuilder create() {
-        return new ItemConfigBuilder();
-    }
-
-    protected final @NotNull String[] params;
-
-    public ConfiguredItem(@NotNull ValueManifest<ItemStack> manifest, @NotNull String[] params) {
-        super(
-                manifest, ItemStack.class,
-                (data, v) -> XItemStack.deserialize((ConfigurationSection) data.getSource()),
-                XItemStack::serialize
-        );
-        this.params = params;
-    }
-
-    public @NotNull String[] getParams() {
-        return params;
-    }
-
-    @Override
-    public @Nullable ItemStack get() {
-        return Optional.ofNullable(super.get()).map(ItemStack::clone).orElse(null);
-    }
-
-    public void modifyItem(Consumer<ItemStack> modifier) {
-        ItemStack item = get();
-        if (item == null) return;
-        modifier.accept(item);
-        set(item);
-    }
-
-    public void modifyMeta(Consumer<ItemMeta> modifier) {
-        modifyItem(item -> {
-            ItemMeta meta = item.getItemMeta();
-            modifier.accept(meta);
-            item.setItemMeta(meta);
-        });
-    }
-
-    public void setName(@Nullable String name) {
-        modifyMeta(meta -> meta.setDisplayName(name));
-    }
-
-    public void setLore(@Nullable List<String> lore) {
-        modifyMeta(meta -> meta.setLore(lore));
-    }
-
-    public void setLore(String... lore) {
-        if (lore.length == 0) setLore((List<String>) null);
-        else setLore(Arrays.asList(lore));
-    }
-
-    public @NotNull PreparedItem prepare(@NotNull Object... values) {
-        return new PreparedItem(this, values);
-    }
-
-    public @Nullable ItemStack get(@Nullable Player player) {
-        return get(player, new HashMap<>());
-    }
-
-    public @Nullable ItemStack get(@Nullable Player player, @NotNull Object... values) {
-        return get(player, ParamsUtils.buildParams(params, values));
-    }
-
-    public @Nullable ItemStack get(@Nullable Player player,
-                                   @NotNull Object[] values,
-                                   @NotNull Map<String, List<String>> inserted) {
-        return get(player, ParamsUtils.buildParams(params, values), inserted);
-    }
-
-
-    public @Nullable ItemStack get(@Nullable Player player, @NotNull String[] params, @NotNull Object[] values) {
-        return get(player, ParamsUtils.buildParams(params, values));
-    }
-
-    public @Nullable ItemStack get(@Nullable Player player,
-                                   @NotNull Map<String, Object> placeholders) {
-        return get(player, placeholders, new HashMap<>());
-    }
-
-    public @Nullable ItemStack get(@Nullable Player player,
-                                   @NotNull Map<String, Object> placeholders,
-                                   @NotNull Map<String, List<String>> inserted) {
-        return get(item -> {
-            ItemMeta meta = item.getItemMeta();
-            if (meta == null) return;
-
-            List<String> lore = insertLore(meta.getLore(), inserted);
-            if (!lore.isEmpty()) {
-                meta.setLore(TextParser.parseList(player, lore, placeholders));
-            }
-
-            String name = meta.getDisplayName();
-            if (!name.isEmpty()) {
-                meta.setDisplayName(TextParser.parseText(player, name, placeholders));
-            }
-
-            item.setItemMeta(meta);
-        });
-    }
-
-    public @Nullable ItemStack get(Consumer<ItemStack> modifier) {
-        return getOptional().map(item -> {
-            modifier.accept(item);
-            return item;
-        }).orElse(null);
-    }
-
-    protected static List<String> insertLore(List<String> original, Map<String, List<String>> inserted) {
-        if (original == null) return Collections.emptyList();
-
-        List<String> finalLore = new ArrayList<>();
-        for (String line : original) {
-            if (line == null) continue;
-
-            Matcher matcher = LORE_INSERT_PATTERN.matcher(line);
-            if (!matcher.matches()) {
-                finalLore.add(line);
-            } else {
-                String path = matcher.group(1);
-                Optional.ofNullable(inserted.get(path)).ifPresent(finalLore::addAll);
-            }
-        }
-
-        return finalLore;
-    }
-
-
-    public static class PreparedItem {
-
-        protected final @NotNull ConfiguredItem itemConfig;
-        protected final @NotNull Map<String, List<String>> insertLore = new HashMap<>();
-
-        protected @NotNull Object[] values;
-
-        protected @NotNull BiConsumer<ItemStack, Player> itemModifier;
-        protected @NotNull BiConsumer<ItemMeta, Player> metaModifier;
-
-        protected PreparedItem(@NotNull ConfiguredItem itemConfig, @NotNull Object[] values) {
-            this.itemConfig = itemConfig;
-            this.values = values;
-            itemModifier = (item, player) -> {
-            };
-            metaModifier = (meta, player) -> {
-            };
-        }
-
-        public PreparedItem modifyMeta(@NotNull BiConsumer<ItemMeta, Player> modifier) {
-            this.metaModifier = this.metaModifier.andThen(modifier);
-            return this;
-        }
-
-        public PreparedItem modifyItem(@NotNull BiConsumer<ItemStack, Player> modifier) {
-            this.itemModifier = this.itemModifier.andThen(modifier);
-            return this;
-        }
-
-        public PreparedItem insertLore(String path, List<String> content) {
-            insertLore.put(path, content);
-            return this;
-        }
-
-        public PreparedItem insertLore(String path, String... content) {
-            return insertLore(path, Arrays.asList(content));
-        }
-
-        public PreparedItem insertLore(String path, ConfiguredList<String> content) {
-            return insertLore(path, content.copy());
-        }
-
-        public PreparedItem insertLore(String path, ConfiguredMessage<String> content, Object... params) {
-            return insertLore(path, content.parse(null, params));
-        }
-
-        public PreparedItem insertLore(String path, ConfiguredMessageList<String> content, Object... params) {
-            return insertLore(path, content.parse(null, params));
-        }
-
-        public PreparedItem values(Object... values) {
-            this.values = values;
-            return this;
-        }
-
-        public PreparedItem amount(int amount) {
-            return modifyItem((item, player) -> item.setAmount(amount));
-        }
-
-        public PreparedItem addEnchantment(Enchantment e) {
-            return addEnchantment(e, 1);
-        }
-
-        public PreparedItem addEnchantment(Enchantment e, int level) {
-            return addEnchantment(e, level, true);
-        }
-
-        public PreparedItem addEnchantment(Enchantment e, int level, boolean ignoreLevelRestriction) {
-            return modifyMeta((meta, player) -> meta.addEnchant(e, level, ignoreLevelRestriction));
-        }
-
-        public PreparedItem addItemFlags(ItemFlag... flags) {
-            return modifyMeta((meta, player) -> meta.addItemFlags(flags));
-        }
-
-        public PreparedItem glow() {
-            return addItemFlags(ItemFlag.HIDE_ENCHANTS).addEnchantment(Enchantment.DURABILITY);
-        }
-
-
-        public @Nullable ItemStack get(Player player) {
-            return Optional.ofNullable(itemConfig.get(player, values, insertLore)).map(item -> {
-                itemModifier.accept(item, player);
-
-                ItemMeta meta = item.getItemMeta();
-                if (meta == null) return item;
-
-                metaModifier.accept(meta, player);
-                item.setItemMeta(meta);
-
-                return item;
-            }).orElse(null);
-        }
-
-    }
-}

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/value/item/ConfiguredItem.java

@@ -0,0 +1,106 @@
+package cc.carm.lib.mineconfiguration.bukkit.value.item;
+
+import cc.carm.lib.configuration.core.value.ValueManifest;
+import cc.carm.lib.configuration.core.value.type.ConfiguredSection;
+import cc.carm.lib.mineconfiguration.bukkit.builder.item.ItemConfigBuilder;
+import com.cryptomorin.xseries.XItemStack;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class ConfiguredItem extends ConfiguredSection<ItemStack> {
+
+
+    public static ItemConfigBuilder create() {
+        return new ItemConfigBuilder();
+    }
+
+    protected final @NotNull String[] params;
+
+    public ConfiguredItem(@NotNull ValueManifest<ItemStack> manifest, @NotNull String[] params) {
+        super(
+                manifest, ItemStack.class,
+                (data, v) -> XItemStack.deserialize((ConfigurationSection) data.getSource()),
+                XItemStack::serialize
+        );
+        this.params = params;
+    }
+
+    public @NotNull String[] getParams() {
+        return params;
+    }
+
+    @Override
+    public @NotNull Optional<@Nullable ItemStack> getOptional() {
+        return Optional.ofNullable(super.get());
+    }
+
+    @Override
+    public @Nullable ItemStack get() {
+        return getOptional().map(ItemStack::clone).orElse(null);
+    }
+
+    public @Nullable ItemStack get(Consumer<ItemStack> modifier) {
+        return getOptional().map(item -> {
+            modifier.accept(item);
+            return item;
+        }).orElse(null);
+    }
+
+    public @NotNull PreparedItem prepare(@NotNull Object... values) {
+        return PreparedItem.of(player -> get()).params(params).values(values);
+    }
+
+    public @Nullable ItemStack get(@Nullable Player player) {
+        return get(player, new HashMap<>());
+    }
+
+    public @Nullable ItemStack get(@Nullable Player player, @NotNull Object... values) {
+        return prepare(values).get(player);
+    }
+
+    public @Nullable ItemStack get(@Nullable Player player, @NotNull String[] params, @NotNull Object[] values) {
+        return prepare().params(params).values(values).get(player);
+    }
+
+    public @Nullable ItemStack get(@Nullable Player player,
+                                   @NotNull Map<String, Object> placeholders) {
+        return prepare().placeholders(placeholders).get(player);
+    }
+
+
+    public void modifyItem(Consumer<ItemStack> modifier) {
+        ItemStack item = get();
+        if (item == null) return;
+        modifier.accept(item);
+        set(item);
+    }
+
+    public void modifyMeta(Consumer<ItemMeta> modifier) {
+        modifyItem(item -> {
+            ItemMeta meta = item.getItemMeta();
+            modifier.accept(meta);
+            item.setItemMeta(meta);
+        });
+    }
+
+    public void setName(@Nullable String name) {
+        modifyMeta(meta -> meta.setDisplayName(name));
+    }
+
+    public void setLore(@Nullable List<String> lore) {
+        modifyMeta(meta -> meta.setLore(lore));
+    }
+
+    public void setLore(String... lore) {
+        if (lore.length == 0) setLore((List<String>) null);
+        else setLore(Arrays.asList(lore));
+    }
+
+}

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/value/item/ItemModifier.java

@@ -0,0 +1,262 @@
+package cc.carm.lib.mineconfiguration.bukkit.value.item;
+
+import cc.carm.lib.configuration.core.value.type.ConfiguredList;
+import cc.carm.lib.mineconfiguration.bukkit.utils.TextParser;
+import cc.carm.lib.mineconfiguration.bukkit.value.ConfiguredMessage;
+import cc.carm.lib.mineconfiguration.bukkit.value.ConfiguredMessageList;
+import cc.carm.lib.mineconfiguration.common.utils.ParamsUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public abstract class ItemModifier<S extends ItemModifier<S, R>, R> {
+
+    public static final @NotNull Pattern LORE_INSERT_PATTERN = Pattern.compile("^(?:\\{(.*)})?#(.*)#(?:\\{(-?\\d+)(?:,(-?\\d+))?})?$");
+
+    protected final @NotNull Function<@NotNull Player, @Nullable ItemStack> itemProvider;
+
+    protected @NotNull Map<String, Object> placeholders = new HashMap<>();
+    protected @NotNull String[] params;
+    protected @NotNull Object[] values;
+
+    protected final @NotNull Map<String, LoreContent> insertLore = new HashMap<>();
+
+    protected @NotNull BiConsumer<ItemStack, Player> itemModifier;
+    protected @NotNull BiConsumer<ItemMeta, Player> metaModifier;
+
+    protected ItemModifier(@NotNull Function<@NotNull Player, @Nullable ItemStack> itemProvider) {
+        this.itemProvider = itemProvider;
+        this.params = new String[0];
+        this.values = new Object[0];
+        itemModifier = (item, player) -> {
+        };
+        metaModifier = (meta, player) -> {
+        };
+    }
+
+    protected abstract @NotNull S getThis();
+
+    public abstract @Nullable R get(Player player);
+
+    public void applyTo(@Nullable ItemStack item, @Nullable Player player) {
+        if (item == null) return;
+
+        ItemMeta meta = item.getItemMeta();
+        if (meta == null) return;
+
+        Map<String, Object> finalPlaceholders = buildPlaceholders();
+
+        String name = meta.getDisplayName();
+        if (!name.isEmpty()) {
+            meta.setDisplayName(TextParser.parseText(player, name, finalPlaceholders));
+        }
+
+        List<String> parsedLore = parseLore(player, meta.getLore(), insertLore, finalPlaceholders);
+        if (!parsedLore.isEmpty()) {
+            meta.setLore(parsedLore);
+        }
+
+        metaModifier.accept(meta, player);
+        item.setItemMeta(meta);
+        itemModifier.accept(item, player);
+    }
+
+    public S handleMeta(@NotNull BiConsumer<ItemMeta, Player> modifier) {
+        this.metaModifier = this.metaModifier.andThen(modifier);
+        return getThis();
+    }
+
+    public S handleItem(@NotNull BiConsumer<ItemStack, Player> modifier) {
+        this.itemModifier = this.itemModifier.andThen(modifier);
+        return getThis();
+    }
+
+    public S params(String[] params) {
+        this.params = params;
+        return getThis();
+    }
+
+    public S values(Object... values) {
+        this.values = values;
+        return getThis();
+    }
+
+    public S placeholders(@NotNull Map<String, Object> placeholders) {
+        this.placeholders = placeholders;
+        return getThis();
+    }
+
+    public S placeholders(@NotNull Consumer<Map<String, Object>> consumer) {
+        Map<String, Object> placeholders = new HashMap<>();
+        consumer.accept(placeholders);
+        return placeholders(placeholders);
+    }
+
+    public S insertLore(@NotNull String path, @NotNull LoreContent content) {
+        insertLore.put(path, content);
+        return getThis();
+    }
+
+    public S insertLore(@NotNull String path, @NotNull List<String> content) {
+        return insertLore(path, content, false);
+    }
+
+    public S insertLore(@NotNull String path, @NotNull List<String> content, boolean original) {
+        return insertLore(path, LoreContent.of(content, original));
+    }
+
+    public S insertLore(@NotNull String path, @NotNull String... content) {
+        return insertLore(path, Arrays.asList(content));
+    }
+
+    public S insertLore(@NotNull String path, @NotNull ConfiguredList<String> content) {
+        return insertLore(path, content.copy());
+    }
+
+    public S insertLore(@NotNull String path,
+                        @NotNull ConfiguredMessage<String> content, @NotNull Object... params) {
+        String c = content.parse(null, params);
+        if (c == null) return getThis();
+        return insertLore(path, c);
+    }
+
+    public S insertLore(@NotNull String path,
+                        @NotNull ConfiguredMessageList<String> content, @NotNull Object... params) {
+        List<String> c = content.parse(null, params);
+        if (c == null || c.isEmpty()) return getThis();
+        return insertLore(path, c);
+    }
+
+    public S amount(int amount) {
+        return handleItem((item, player) -> item.setAmount(amount));
+    }
+
+    public S addEnchantment(Enchantment e) {
+        return addEnchantment(e, 1);
+    }
+
+    public S addEnchantment(Enchantment e, int level) {
+        return addEnchantment(e, level, true);
+    }
+
+    public S addEnchantment(Enchantment e, int level, boolean ignoreLevelRestriction) {
+        return handleMeta((meta, player) -> meta.addEnchant(e, level, ignoreLevelRestriction));
+    }
+
+    public S addItemFlags(ItemFlag... flags) {
+        return handleMeta((meta, player) -> meta.addItemFlags(flags));
+    }
+
+    public S glow() {
+        return addItemFlags(ItemFlag.HIDE_ENCHANTS).addEnchantment(Enchantment.DURABILITY);
+    }
+
+    /**
+     * @param owner 玩家名
+     * @return this
+     * @deprecated Use {@link #setSkullOwner(OfflinePlayer)} instead.
+     */
+    @Deprecated
+    public S setSkullOwner(String owner) {
+        return handleItem((item, player) -> {
+            if (!(item.getItemMeta() instanceof SkullMeta)) return;
+            SkullMeta meta = (SkullMeta) item.getItemMeta();
+            meta.setOwner(owner);
+        });
+    }
+
+    public S setSkullOwner(UUID owner) {
+        return setSkullOwner(Bukkit.getOfflinePlayer(owner));
+    }
+
+    public S setSkullOwner(OfflinePlayer owner) {
+        return handleItem((item, player) -> {
+            if (!(item.getItemMeta() instanceof SkullMeta)) return;
+            SkullMeta meta = (SkullMeta) item.getItemMeta();
+            meta.setOwningPlayer(owner);
+        });
+    }
+
+
+    protected Map<String, Object> buildPlaceholders() {
+        Map<String, Object> finalPlaceholders = new HashMap<>();
+        finalPlaceholders.putAll(ParamsUtils.buildParams(params, values));
+        finalPlaceholders.putAll(this.placeholders);
+        return finalPlaceholders;
+    }
+
+    public static List<String> parseLore(@Nullable Player player, @Nullable List<String> lore,
+                                         @NotNull Map<String, LoreContent> insertedLore,
+                                         @NotNull Map<String, Object> placeholders) {
+        List<String> parsedLore = new ArrayList<>();
+        if (lore == null || lore.isEmpty()) return parsedLore;
+
+        for (String line : lore) {
+            Matcher matcher = LORE_INSERT_PATTERN.matcher(line);
+            if (!matcher.matches()) {
+                parsedLore.add(TextParser.parseText(player, line, placeholders));
+                continue;
+            }
+
+            String path = matcher.group(2);
+            LoreContent content = insertedLore.get(path);
+            if (content == null) continue;
+
+            String prefix = Optional.ofNullable(matcher.group(1))
+                    .map(s -> TextParser.parseText(player, s, placeholders))
+                    .orElse("");
+            int offset1 = Optional.ofNullable(matcher.group(3))
+                    .map(Integer::parseInt).orElse(0);
+            Integer offset2 = Optional.ofNullable(matcher.group(4))
+                    .map(Integer::parseInt).orElse(null);
+
+            List<String> inserted = parseLoreLine(
+                    player, content, placeholders, prefix,
+                    offset2 == null ? 0 : offset1, offset2 == null ? offset1 : offset2
+            );
+
+            if (content.isOriginal()) {
+                parsedLore.addAll(inserted);
+            } else {
+                parsedLore.addAll(TextParser.parseList(player, inserted, placeholders));
+            }
+        }
+        return parsedLore;
+    }
+
+    public static List<String> parseLoreLine(@Nullable Player player, @NotNull LoreContent content,
+                                             @NotNull Map<String, Object> placeholders,
+                                             @NotNull String parsedPrefix, int upOffset, int downOffset) {
+        if (content.getContent().isEmpty()) return Collections.emptyList();
+
+        upOffset = Math.max(0, upOffset);
+        downOffset = Math.max(0, downOffset);
+
+        List<String> finalLore = new ArrayList<>();
+
+        for (int i = 0; i < upOffset; i++) finalLore.add(" ");
+        if (content.isOriginal()) {
+            content.getContent().stream().map(s -> parsedPrefix + s).forEach(finalLore::add);
+        } else {
+            content.getContent().stream().map(s -> parsedPrefix + TextParser.parseText(player, s, placeholders))
+                    .forEach(finalLore::add);
+        }
+        for (int i = 0; i < downOffset; i++) finalLore.add(" ");
+
+        return finalLore;
+    }
+}

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/value/item/LoreContent.java

@@ -0,0 +1,35 @@
+package cc.carm.lib.mineconfiguration.bukkit.value.item;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class LoreContent {
+
+    public static LoreContent of(@NotNull List<String> content) {
+        return of(content, false);
+    }
+
+    public static LoreContent of(@NotNull List<String> content, boolean original) {
+        return new LoreContent(content, original);
+    }
+
+    protected final @NotNull List<String> content;
+    protected final boolean original;
+
+    public LoreContent(@NotNull List<String> content, boolean original) {
+        this.content = content;
+        this.original = original;
+    }
+
+
+    public @NotNull List<String> getContent() {
+        return content;
+    }
+
+    public boolean isOriginal() {
+        return original;
+    }
+
+
+}

platform/bukkit/src/main/java/cc/carm/lib/mineconfiguration/bukkit/value/item/PreparedItem.java

@@ -0,0 +1,37 @@
+package cc.carm.lib.mineconfiguration.bukkit.value.item;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+
+public class PreparedItem extends ItemModifier<PreparedItem, ItemStack> {
+
+    public static PreparedItem of(@NotNull Function<@NotNull Player, @Nullable ItemStack> itemProvider) {
+        return new PreparedItem(itemProvider);
+    }
+
+    public static PreparedItem of(@Nullable ItemStack item) {
+        return of(player -> item);
+    }
+
+    public PreparedItem(@NotNull Function<@NotNull Player, @Nullable ItemStack> itemProvider) {
+        super(itemProvider);
+    }
+
+    public @Nullable ItemStack get(Player player) {
+        @Nullable ItemStack item = itemProvider.apply(player);
+        if (item == null) return null;
+
+        applyTo(item, player);
+        return item;
+    }
+
+    @Override
+    public @NotNull PreparedItem getThis() {
+        return this;
+    }
+
+}

platform/bukkit/src/test/java/LoreInsertTest.java

@@ -0,0 +1,55 @@
+import cc.carm.lib.mineconfiguration.bukkit.value.item.LoreContent;
+import cc.carm.lib.mineconfiguration.bukkit.value.item.PreparedItem;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+
+public class LoreInsertTest {
+
+
+    @Test
+    public void insert() {
+        List<String> original = Arrays.asList(
+                "测试lore的第一行",
+                "测试lore的第二行",
+                "#click-lore#{1,2}",
+                "测试lore的倒数第二行",
+                "{--> }#click-lore#{2}",
+                "测试lore的倒数第一行"
+        );
+
+        List<String> replace = Arrays.asList("> 插入的点击行1", "> 插入的点击行2");
+        Map<String, LoreContent> inserted = new HashMap<>();
+        inserted.put("click-lore", LoreContent.of(replace));
+        PreparedItem.parseLore(null, original, inserted, new HashMap<>()).forEach(System.out::println);
+    }
+
+
+    @Test
+    public void parse() {
+        System.out.println(parse("{LOVE}#click-lore#{1,0}"));
+        System.out.println(parse("#click-lore#{1,2}"));
+        System.out.println(parse("#click-lore#{1}"));
+        System.out.println(parse("#click-lore#{我}"));
+    }
+
+    public static String parse(String line) {
+        Matcher matcher = PreparedItem.LORE_INSERT_PATTERN.matcher(line);
+        if (!matcher.matches()) {
+            return "Failed -> [" + line + "]";
+        } else {
+            String prefix = matcher.group(1);
+            String path = matcher.group(2);
+
+            String offset1 = matcher.group(3);
+            String offset2 = matcher.group(4);
+            return "Prefix -> [" + prefix + "] Path -> [" + path + "] Offset-> [" + offset1 + "/" + offset2 + "]";
+        }
+    }
+
+
+}

platform/bungee/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>mineconfiguration-parent</artifactId>
         <groupId>cc.carm.lib</groupId>
-        <version>2.8.2</version>
+        <version>2.8.7</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>

pom.xml

@@ -11,13 +11,13 @@
         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
 
         <deps.easyconfifuration.version>3.8.0</deps.easyconfifuration.version>
-        <deps.easyplugin.version>1.5.7</deps.easyplugin.version>
+        <deps.easyplugin.version>1.5.8</deps.easyplugin.version>
         <deps.yamlcommentwriter.version>1.0.1</deps.yamlcommentwriter.version>
     </properties>
 
     <groupId>cc.carm.lib</groupId>
     <artifactId>mineconfiguration-parent</artifactId>
-    <version>2.8.2</version>
+    <version>2.8.7</version>
     <packaging>pom</packaging>
     <modules>
         <module>common</module>
@@ -196,7 +196,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-javadoc-plugin</artifactId>
-                    <version>3.5.0</version>
+                    <version>3.6.0</version>
                     <configuration>
                         <classifier>javadoc</classifier>
                         <detectJavaApiLink>false</detectJavaApiLink>
@@ -225,7 +225,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-shade-plugin</artifactId>
-                    <version>3.5.0</version>
+                    <version>3.5.1</version>
                     <executions>
                         <execution>
                             <phase>package</phase>