refactor: port to 26.1-snapshot-11

common/src/main/java/dev/potota/itemstats/interfaces/MaxStackSize.java

···
+package dev.potota.itemstats.interfaces;
+
+public interface MaxStackSize {
+    int itemstats$getMaxStackSize();
+}

common/src/main/java/dev/potota/itemstats/mixin/ItemMixin.java

···
 
 import dev.potota.itemstats.api.ItemStats;
 import dev.potota.itemstats.api.StatsComponent;
-import net.minecraft.core.component.DataComponentMap;
+import dev.potota.itemstats.interfaces.MaxStackSize;
+import net.minecraft.core.component.DataComponentType;
 import net.minecraft.core.component.DataComponents;
 import net.minecraft.world.item.Item;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyVariable;
-
-// TODO figure out TooltipProvider
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(Item.class)
 public abstract class ItemMixin {
     // Add our custom component to all unstackable items
     @ModifyVariable(method = "<init>", at = @At("HEAD"), argsOnly = true)
     private static Item.Properties itemstats$injectStatsComponent(Item.Properties properties) {
-        DataComponentMap defaultComponents = ((ItemPropertiesComponentAccess)properties).itemstats$getComponents().build();
-        if (defaultComponents.getOrDefault(DataComponents.MAX_STACK_SIZE, 0) == 1) {
+        if (((MaxStackSize)properties).itemstats$getMaxStackSize() == 1) {
             return properties.component(ItemStats.STATS_COMPONENT, StatsComponent.empty());
         }
         return properties;
+    }
+
+    @Mixin(Item.Properties.class)
+    public abstract static class PropertiesMixin implements MaxStackSize {
+        @Unique
+        public int itemstats$maxStackSize = 0;
+
+        @Inject(method = "component", at = @At("HEAD"))
+        private <T> void itemstats$trackMaxStackSize(DataComponentType<T> type, T value, CallbackInfoReturnable<Item.Properties> cir) {
+            if (type == DataComponents.MAX_STACK_SIZE) {
+                this.itemstats$maxStackSize = (int) value;
+            }
+        }
+
+        @Override
+        public int itemstats$getMaxStackSize() {
+            return this.itemstats$maxStackSize;
+        }
     }
 }

common/src/main/java/dev/potota/itemstats/mixin/ItemPropertiesComponentAccess.java

···
-package dev.potota.itemstats.mixin;
-
-import net.minecraft.core.component.DataComponentMap;
-import net.minecraft.world.item.Item;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(Item.Properties.class)
-public interface ItemPropertiesComponentAccess {
-    @Accessor("components") DataComponentMap.Builder itemstats$getComponents();
-}

common/src/main/java/dev/potota/itemstats/mixin/ItemStackMixin.java

···
 import dev.potota.itemstats.api.StatsComponent;
 import dev.potota.itemstats.impl.ItemStatsImpl;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
 import net.minecraft.core.component.PatchedDataComponentMap;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.resources.Identifier;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.ItemLike;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.state.BlockState;
 import org.spongepowered.asm.mixin.Final;
···
 
     @Final
     @Shadow
-    PatchedDataComponentMap components;
+    private PatchedDataComponentMap components;
 
-    @Inject(method = "<init>(Lnet/minecraft/world/level/ItemLike;ILnet/minecraft/core/component/PatchedDataComponentMap;)V", at = @At("RETURN"))
-    private void itemstats$addDefaultStats(ItemLike itemLike, int count, PatchedDataComponentMap components, CallbackInfo ci) {
+    @Inject(method = "<init>(Lnet/minecraft/core/Holder;ILnet/minecraft/core/component/PatchedDataComponentMap;)V", at = @At("RETURN"))
+    private void itemstats$addDefaultStats(Holder<Item> itemHolder, int count, PatchedDataComponentMap components, CallbackInfo ci) {
         StatsComponent currentStats = components.get(ItemStats.STATS_COMPONENT);
         if (currentStats == null) {
             return;
         }
 
         StatsComponent newStats = new StatsComponent(currentStats);
-        Item item = itemLike.asItem();
+        Item item = itemHolder.value();
 
         try {
             for (var entry : ItemStats.Registries.STAT.entrySet()) {

common/src/main/java/dev/potota/itemstats/mixin/ServerPlayerMixin.java

···
 
     @Inject(
             method = "checkMovementStatistics",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;awardStat(Lnet/minecraft/resources/Identifier;I)V"),
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;awardStat(Lnet/minecraft/resources/Identifier;I)V", ordinal = 0),
             slice = @Slice(
-                    from = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;isFallFlying()Z"),
-                    to = @At(value = "CONSTANT", args = "intValue=25")
+                    from = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;isFallFlying()Z")
             )
     )
     private void itemstats$distanceFlown(double dx, double dy, double dz, CallbackInfo ci) {

common/src/main/resources/itemstats.mixins.json

···
 {
-  "required": true,
-  "minVersion": "0.8",
-  "package": "dev.potota.itemstats.mixin",
-  "refmap": "${mod_id}.refmap.json",
-  "compatibilityLevel": "JAVA_18",
-  "mixins": [
-    "AbstractArrowMixin",
-    "ItemMixin",
-    "ItemPropertiesComponentAccess",
-    "ItemStackMixin",
-    "LivingEntityMixin",
-    "ProjectileWeaponItemMixin",
-    "ServerPlayerMixin",
-    "ThrownTridentMixin"
-  ],
-  "client": [
-    "client.KeyAccess"
-  ],
-  "server": [],
-  "injectors": {
-    "defaultRequire": 1
+    "required": true,
+    "minVersion": "0.8",
+    "package": "dev.potota.itemstats.mixin",
+    "refmap": "${mod_id}.refmap.json",
+    "compatibilityLevel": "JAVA_18",
+    "mixins": [
+        "AbstractArrowMixin",
+        "ItemMixin",
+        "ItemMixin\$PropertiesMixin",
+        "ItemStackMixin",
+        "LivingEntityMixin",
+        "ProjectileWeaponItemMixin",
+        "ServerPlayerMixin",
+        "ThrownTridentMixin"
+    ],
+    "client": [
+        "client.KeyAccess"
+    ],
+    "server": [],
+    "injectors": {
+        "defaultRequire": 1
   }
 }

common/src/test/java/dev/potota/itemstats/gametest/ItemStatsGameTests.java

···
 import net.minecraft.resources.Identifier;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.stats.Stats;
+import net.minecraft.util.Unit;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.EquipmentSlot;
···
         test.assertMainHandStat(player, BuiltInStats.MOBS_SHEARED, "minecraft:sheep", 0);
 
         Sheep sheep = test.spawnWithNoFreeWill(EntityType.SHEEP, 0, 1, 0);
-        player.interactOn(sheep, InteractionHand.MAIN_HAND);
+        player.interactOn(sheep, InteractionHand.MAIN_HAND, new Vec3(0, 0, 0));
 
         test.assertMainHandStat(player, BuiltInStats.MOBS_SHEARED, "minecraft:sheep", 1);
 
···
         return functions;
     }
 
-    public static Map<Identifier, TestData<Holder<TestEnvironmentDefinition>>> collectTestData(Registry<TestEnvironmentDefinition> testEnvironmentDefinitions) {
-        Map<Identifier, TestData<Holder<TestEnvironmentDefinition>>> data = new HashMap<>();
+    public static Map<Identifier, TestData<Holder<TestEnvironmentDefinition<?>>>> collectTestData(Registry<TestEnvironmentDefinition<?>> testEnvironmentDefinitions) {
+        Map<Identifier, TestData<Holder<TestEnvironmentDefinition<?>>>> data = new HashMap<>();
         for (Method method : ItemStatsGameTests.class.getDeclaredMethods()) {
             Test testOptions = method.getAnnotation(Test.class);
             if (testOptions == null) continue;
 
-            Optional<Holder.Reference<TestEnvironmentDefinition>> environment = testEnvironmentDefinitions.get(ResourceKey.create(Registries.TEST_ENVIRONMENT, Identifier.parse(testOptions.environment())));
+            Optional<Holder.Reference<TestEnvironmentDefinition<?>>> environment = testEnvironmentDefinitions.get(Identifier.parse(testOptions.environment()));
             if (environment.isEmpty()) {
                 LOGGER.error("Could not find test environment " + testOptions.environment());
                 continue;
···
                     testOptions.manualOnly(),
                     testOptions.maxAttempts(),
                     testOptions.requiredSuccesses(),
-                    testOptions.skyAccess()
+                    testOptions.skyAccess(),
+                    0
             ));
         }
 

common/src/test/resources/itemstats_test.accesswidener

···
 accessWidener v1 official
 
 # Only used
-accessible class net/minecraft/resources/RegistryDataLoader$Loader
+#accessible class net/minecraft/resources/RegistryDataLoader$Loader

fabric/src/main/java/dev/potota/itemstats/impl/client/ItemStatsClientFabric.java

···
 
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback;
-import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+import net.fabricmc.fabric.api.client.keymapping.v1.KeyMappingHelper;
 
 public class ItemStatsClientFabric implements ClientModInitializer {
     @Override
     public void onInitializeClient() {
-        ItemStatsClientImpl.registerKeys(KeyBindingHelper::registerKeyBinding);
+        ItemStatsClientImpl.registerKeys(KeyMappingHelper::registerKeyMapping);
         ItemTooltipCallback.EVENT.register((stack, tooltipContext, tooltipFlag, lines) -> ItemStatsClientImpl.onTooltipRender(stack));
     }
 }

fabric/src/main/java/dev/potota/itemstats/platform/FabricPlatformHelper.java

···
 public class FabricPlatformHelper implements IPlatformHelper {
     @Override
     public <T> Registry<T> createRegistry(ResourceKey<Registry<T>> key) {
-        return FabricRegistryBuilder.createSimple(key).attribute(RegistryAttribute.SYNCED).buildAndRegister();
+        return FabricRegistryBuilder.create(key).attribute(RegistryAttribute.SYNCED).buildAndRegister();
     }
 
     @Override

fabric/src/test/java/dev/potota/itemstats/mixin/FabricGameTestModInitializerMixin.java

···
 import net.minecraft.gametest.framework.GameTestInstance;
 import net.minecraft.gametest.framework.TestData;
 import net.minecraft.gametest.framework.TestEnvironmentDefinition;
-import net.minecraft.resources.RegistryDataLoader;
+import net.minecraft.resources.RegistryLoadTask;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.Identifier;
 import org.spongepowered.asm.mixin.Mixin;
···
 
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 
 @Mixin(FabricGameTestModInitializer.class)
 public class FabricGameTestModInitializerMixin {
     @Inject(method = "registerDynamicEntries", at = @At("TAIL"))
-    private static void itemstats$addTests(List<RegistryDataLoader.Loader<?>> registriesList, CallbackInfo ci, @Local(name = "registries") Map<ResourceKey<? extends Registry<?>>, Registry<?>> registries) {
-        Registry<GameTestInstance> testInstances = (Registry<GameTestInstance>) registries.get(Registries.TEST_INSTANCE);
-        Registry<TestEnvironmentDefinition> testEnvironmentDefinitions = (Registry<TestEnvironmentDefinition>) Objects.requireNonNull(registries.get(Registries.TEST_ENVIRONMENT));
-        for (Map.Entry<Identifier, TestData<Holder<TestEnvironmentDefinition>>> entry : ItemStatsGameTests.collectTestData(testEnvironmentDefinitions).entrySet()) {
+    private static void itemstats$addTests(List<RegistryLoadTask<?>> registriesList, CallbackInfo ci, @Local(name = "testInstances") Registry<GameTestInstance> testInstances, @Local(name = "testEnvironmentDefinitionRegistry") Registry<TestEnvironmentDefinition<?>> testEnvironmentDefinitionRegistry) {
+        for (Map.Entry<Identifier, TestData<Holder<TestEnvironmentDefinition<?>>>> entry : ItemStatsGameTests.collectTestData(testEnvironmentDefinitionRegistry).entrySet()) {
             Registry.register(
                     testInstances, entry.getKey(),
                     new FunctionGameTestInstance(ResourceKey.create(Registries.TEST_FUNCTION, entry.getKey()), entry.getValue())

gradle.properties

···
 license=All Rights Reserved
 credits=
 description=Tracks usage stats on all of your gear!
-minecraft_version_range_fabric=26.1-snapshot-11
-minecraft_version_range_neoforge=[26.1-snapshot-11]
+minecraft_version_range_fabric=*
+minecraft_version_range_neoforge=[1.21.11,)
 
 # NeoForm - https://projects.neoforged.net/neoforged/neoform
 neo_form_version=26.1-snapshot-11-1
···
 # Fabric - https://fabricmc.net/develop/
 fabric_api_version=0.143.10
 fabric_api_minecraft=26.1
-fabric_loader_version=0.18.1
+fabric_loader_version=0.18.4
 
 # NeoForge - https://projects.neoforged.net/neoforged/neoforge
 neoforge_version=26.1.0.0-alpha.10+snapshot-6

neoforge/src/main/java/dev/potota/itemstats/mixin/neoforge/LivingEntityMixin.java

···
     }
 
     @Inject(method = "applyItemBlocking", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/item/component/BlocksAttacks;hurtBlockingItem(Lnet/minecraft/world/level/Level;Lnet/minecraft/world/item/ItemStack;Lnet/minecraft/world/entity/LivingEntity;Lnet/minecraft/world/InteractionHand;FI)V"))
-    private void itemstats$trackShieldDamage(ServerLevel level, DamageSource damageSource, float damageAmount, CallbackInfoReturnable<Float> cir, @Local(name = "f") float damageAfterShield, @Local ItemStack shield) {
+    private void itemstats$trackShieldDamage(ServerLevel level, DamageSource damageSource, float damageAmount, CallbackInfoReturnable<Float> cir, @Local(name = "damageBlocked") float damageAfterShield, @Local ItemStack shield) {
         Identifier damageType = this.registryAccess().lookup(Registries.DAMAGE_TYPE).get().getKey(damageSource.type());
         BuiltInStats.DAMAGE_ABSORBED.increment(shield, damageType, damageAfterShield);
     }

neoforge/src/test/java/dev/potota/itemstats_test/ItemStatsTestNeoForge.java

···
 
     @SubscribeEvent
     public static void registerTestInstances(RegisterGameTestsEvent event) {
-        Registry<TestEnvironmentDefinition> environments = ((RegisterGameTestsEventAccessor)event).itemstats$getEnvironmentsRegistry();
-        Map<Identifier, TestData<Holder<TestEnvironmentDefinition>>> testData = ItemStatsGameTests.collectTestData(environments);
+        Registry<TestEnvironmentDefinition<?>> environments = ((RegisterGameTestsEventAccessor)event).itemstats$getEnvironmentsRegistry();
+        Map<Identifier, TestData<Holder<TestEnvironmentDefinition<?>>>> testData = ItemStatsGameTests.collectTestData(environments);
         for (var entry : testData.entrySet()) {
             event.registerTest(entry.getKey(), new FunctionGameTestInstance(
                     ResourceKey.create(BuiltInRegistries.TEST_FUNCTION.key(), entry.getKey()),

neoforge/src/test/java/dev/potota/itemstats_test/mixin/RegisterGameTestsEventAccessor.java

···
 
 @Mixin(RegisterGameTestsEvent.class)
 public interface RegisterGameTestsEventAccessor {
-    @Accessor("environmentsRegistry") WritableRegistry<TestEnvironmentDefinition> itemstats$getEnvironmentsRegistry();
+    @Accessor("environmentsRegistry") WritableRegistry<TestEnvironmentDefinition<?>> itemstats$getEnvironmentsRegistry();
 }