Make recipe viewer slots more generic and fix some emi stuff

src/main/java/brachy/modularui/drawable/text/DynamicComponent.java

@@ -5,6 +5,8 @@
 import brachy.modularui.screen.viewport.GuiContext;
 import brachy.modularui.theme.WidgetTheme;
 
+import brachy.modularui.widgets.TextWidget;
+
 import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.ComponentContents;
@@ -62,6 +64,11 @@ private Component getComp() {
         return getComp().getVisualOrderText();
     }
 
+    @Override
+    public TextWidget<?> asWidget() {
+        return new TextWidget<>(this::getComp);
+    }
+
     @Override
     public void draw(GuiContext context, int x, int y, int width, int height, WidgetTheme widgetTheme) {
         Component comp = getComp();

src/main/java/brachy/modularui/integration/emi/EmiRecipeViewerSlot.java

@@ -0,0 +1,108 @@
+package brachy.modularui.integration.emi;
+
+import brachy.modularui.drawable.ClientTooltipComponentIcon;
+import brachy.modularui.drawable.GuiTextures;
+import brachy.modularui.integration.recipeviewer.RecipeSlotRole;
+import brachy.modularui.integration.recipeviewer.RecipeViewerSlotWidget;
+import brachy.modularui.integration.recipeviewer.entry.EntryList;
+import brachy.modularui.integration.recipeviewer.entry.fluid.FluidEntryList;
+import brachy.modularui.integration.recipeviewer.entry.item.ItemEntryList;
+
+import brachy.modularui.screen.viewport.ModularGuiContext;
+import brachy.modularui.theme.WidgetThemeEntry;
+
+import dev.emi.emi.api.stack.EmiIngredient;
+import dev.emi.emi.api.widget.SlotWidget;
+
+import dev.emi.emi.api.widget.TankWidget;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.world.item.crafting.Ingredient;
+
+import org.jetbrains.annotations.ApiStatus;
+
+public class EmiRecipeViewerSlot extends RecipeViewerSlotWidget<EmiRecipeViewerSlot> {
+
+    @ApiStatus.Internal
+    @Getter
+    private SlotWidget slotWidget;
+    private int x, y;
+
+    @Accessors(fluent = true)
+    @Getter
+    private RecipeSlotRole recipeSlotRole;
+    private EntryList<?> value;
+    @Accessors(fluent = true)
+    @Getter
+    @Setter
+    private float chance = 1f;
+
+    public EmiRecipeViewerSlot() {
+        super();
+        slotWidget = new SlotWidget(EmiIngredient.of(Ingredient.EMPTY), 0, 0);
+        recipeSlotRole = RecipeSlotRole.RENDER_ONLY;
+
+        size(18, 18);
+
+        tooltipAutoUpdate(true);
+        tooltipDynamic(tooltip -> {
+            for (ClientTooltipComponent ctc : this.slotWidget.getTooltip(getContext().getAbsMouseX(), getContext().getAbsMouseY())) {
+                tooltip.addDrawableLine(new ClientTooltipComponentIcon(ctc));
+            }
+        });
+    }
+
+    @Override
+    public EmiRecipeViewerSlot recipeSlotRole(RecipeSlotRole recipeSlotRole) {
+        this.recipeSlotRole = recipeSlotRole;
+        slotWidget.catalyst(recipeSlotRole == RecipeSlotRole.CATALYST);
+        return getThis();
+    }
+
+    @Override
+    public EmiRecipeViewerSlot value(FluidEntryList fluidEntryList) {
+        value = fluidEntryList;
+        rebuildEmiSlot();
+        background(GuiTextures.SLOT_FLUID);
+        return getThis();
+    }
+
+    @Override
+    public EmiRecipeViewerSlot value(ItemEntryList itemEntryList) {
+        value = itemEntryList;
+        rebuildEmiSlot();
+        background(GuiTextures.SLOT_ITEM);
+        return getThis();
+    }
+
+    private void rebuildEmiSlot() {
+        if (value instanceof ItemEntryList itemEntryList) {
+            slotWidget = new SlotWidget(EmiStackConverter.ITEM.convertTo(itemEntryList, chance), 0, 0);
+        } else if (value instanceof FluidEntryList fluidEntryList) {
+            slotWidget = new TankWidget(EmiStackConverter.FLUID.convertTo(fluidEntryList, chance), 0, 0, 18, 18, 1);
+        }
+        slotWidget.drawBack(false);
+    }
+
+    @Override
+    public void draw(ModularGuiContext context, WidgetThemeEntry<?> widgetTheme) {
+        context.getGraphics().pose().translate(-this.x, -this.y, 0);
+        this.slotWidget.render(context.getGraphics(), context.getMouseX(), context.getMouseY(), context.getRenderPartialTicks());
+        context.getGraphics().pose().translate(this.x, this.y, 0);
+    }
+
+    @Override
+    public Result onMousePressed(int button) {
+        this.slotWidget.mouseClicked(getContext().getMouseX(), getContext().getAbsMouseY(), button);
+        return Result.SUCCESS;
+    }
+
+    @Override
+    public Result onKeyPressed(int keyCode, int scanCode, int modifiers) {
+        return this.slotWidget.keyPressed(keyCode, scanCode, modifiers) ? Result.SUCCESS : Result.ACCEPT;
+    }
+}

src/main/java/brachy/modularui/integration/emi/EmiStackConverter.java

@@ -23,7 +23,6 @@
 
 import java.util.Map;
 import java.util.Optional;
-import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -52,8 +51,7 @@ private static EmiIngredient toEMIIngredient(Stream<ItemStack> stream) {
         }
 
         @Override
-        public EmiIngredient convertTo(EntryList<ItemStack> stack, float chance,
-                                       UnaryOperator<ItemStack> mapper) {
+        public EmiIngredient convertTo(EntryList<ItemStack> stack, float chance) {
             if (stack.isEmpty()) {
                 return EmiStack.EMPTY;
             }
@@ -84,13 +82,12 @@ private static EmiIngredient toEMIIngredient(Stream<FluidStack> stream) {
         }
 
         @Override
-        public EmiIngredient convertTo(EntryList<FluidStack> stack, float chance,
-                                       UnaryOperator<FluidStack> mapper) {
+        public EmiIngredient convertTo(EntryList<FluidStack> stack, float chance) {
             if (stack.isEmpty()) {
                 return EmiStack.EMPTY;
             }
             if (stack instanceof FluidStackList stackList) {
-                return toEMIIngredient(stackList.stream().map(mapper)).setChance(chance);
+                return toEMIIngredient(stackList.stream()).setChance(chance);
             } else if (stack instanceof FluidTagList tagList) {
                 return EmiIngredient.of(tagList.getEntries().stream()
                         .map(FluidTagList.FluidTagEntry::stacks)
@@ -121,10 +118,10 @@ public interface Converter<T> {
         @Nullable
         T convertFrom(EmiStack stack);
 
-        EmiIngredient convertTo(EntryList<T> stack, float chance, UnaryOperator<T> mapper);
+        EmiIngredient convertTo(EntryList<T> stack, float chance);
 
         default EmiIngredient convertTo(IngredientProvider<T> slot) {
-            return this.convertTo(slot.getIngredients(), slot.chance(), slot.renderMappingFunction());
+            return this.convertTo(slot.getIngredients(), slot.chance());
         }
     }
 }

src/main/java/brachy/modularui/integration/emi/recipe/ModularUIEmiRecipe.java

@@ -1,19 +1,16 @@
 package brachy.modularui.integration.emi.recipe;
 
 import brachy.modularui.ModularUI;
-import brachy.modularui.api.IThemeApi;
 import brachy.modularui.api.drawable.IRichTextBuilder;
 import brachy.modularui.api.widget.ITooltip;
 import brachy.modularui.api.widget.IWidget;
 import brachy.modularui.drawable.text.RichText;
+import brachy.modularui.integration.emi.EmiRecipeViewerSlot;
 import brachy.modularui.integration.recipeviewer.RecipeSlotRole;
-import brachy.modularui.integration.recipeviewer.handlers.IngredientProvider;
 import brachy.modularui.screen.EmbedHandler;
 import brachy.modularui.screen.ModularPanel;
 import brachy.modularui.screen.ModularScreen;
 import brachy.modularui.screen.RichTooltip;
-import brachy.modularui.theme.WidgetThemeKey;
-import brachy.modularui.widgets.slot.FluidSlot;
 
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
@@ -27,7 +24,6 @@
 import dev.emi.emi.api.stack.EmiStack;
 import dev.emi.emi.api.widget.Bounds;
 import dev.emi.emi.api.widget.SlotWidget;
-import dev.emi.emi.api.widget.TankWidget;
 import dev.emi.emi.api.widget.Widget;
 import dev.emi.emi.api.widget.WidgetHolder;
 import org.jetbrains.annotations.Nullable;
@@ -118,41 +114,14 @@ public ModularPanel<?> transform(ModularPanel<?> panel) {
     }
 
     public IWidget transformWidget(IWidget widget, Iterator<EmiIngredient> in, Iterator<EmiStack> out) {
-        if (!(widget instanceof IngredientProvider<?> provider)) return widget;
 
-        RecipeSlotRole role = provider.getRecipeRole();
-        if (role == RecipeSlotRole.RENDER_ONLY) return widget;
+        if (!(widget instanceof EmiRecipeViewerSlot recipeViewerSlot)) return widget;
 
-        EmiIngredient ingr = EmiStack.EMPTY;
-        if (role == RecipeSlotRole.INPUT && in.hasNext()) {
-            ingr = in.next();
-        } else if (role == RecipeSlotRole.OUTPUT && out.hasNext()) {
-            ingr = out.next();
+        if (recipeViewerSlot.recipeSlotRole() == RecipeSlotRole.OUTPUT) {
+            recipeViewerSlot.getSlotWidget().recipeContext(this);
         }
 
-        SlotWidget emiSlot = null;
-        WidgetThemeKey<?> widgetThemeKey = null;
-        if (widget instanceof FluidSlot slot) {
-            if (!slot.isAlwaysShowFull()) {
-                emiSlot = new TankWidget(ingr, 0, 0, slot.getArea().width, slot.getArea().height, slot.getCapacity());
-            }
-            widgetThemeKey = IThemeApi.FLUID_SLOT;
-        }
-        if (emiSlot == null) emiSlot = new SlotWidget(ingr, 0, 0);
-        if (widgetThemeKey == null) widgetThemeKey = IThemeApi.ITEM_SLOT;
-
-        emiSlot.drawBack(false);
-
-        if (role == RecipeSlotRole.CATALYST) {
-            emiSlot.catalyst(true);
-        } else if (role == RecipeSlotRole.OUTPUT) {
-            emiSlot.recipeContext(this);
-        }
-
-        return new EMISlotWidgetWrapper<>(emiSlot)
-                .copyResizerOf(widget)
-                .copyVisualsOf(widget)
-                .widgetTheme(widgetThemeKey);
+        return recipeViewerSlot;
     }
 
     @Override

src/main/java/brachy/modularui/integration/jei/JeiIngredientHandler.java

@@ -0,0 +1,56 @@
+package brachy.modularui.integration.jei;
+
+import brachy.modularui.integration.recipeviewer.entry.fluid.FluidEntryList;
+import brachy.modularui.integration.recipeviewer.entry.item.ItemEntryList;
+
+import mezz.jei.common.input.ClickableIngredient;
+import mezz.jei.common.util.ImmutableRect2i;
+
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static brachy.modularui.integration.jei.ModularUIJeiPlugin.jeiHelpers;
+
+public class JeiIngredientHandler {
+
+    public static List<ItemStack> toJeiIngredient(ItemEntryList list) {
+        return list.getStacks()
+                .stream()
+                .filter(stack -> !stack.isEmpty())
+                .collect(Collectors.toList());
+    }
+
+    public static List<FluidStack> toJeiIngredient(FluidEntryList list) {
+        return list.getStacks()
+                .stream()
+                .filter(stack -> !stack.isEmpty())
+                .toList();
+    }
+
+    public static <T> @Nullable ClickableIngredient<T> getJEIStackClickable(T stack, int x, int y, int w, int h) {
+        return jeiHelpers.getIngredientManager().createTypedIngredient(stack)
+                .map(typedIngredient -> new ClickableIngredient<>(typedIngredient, new ImmutableRect2i(x, y, w, h)))
+                .orElse(null);
+    }
+
+    public static List<ClickableIngredient<ItemStack>> toJeiIngredientClickable(ItemEntryList list, int x, int y, int w, int h) {
+        return list.getStacks()
+                .stream()
+                .filter(stack -> !stack.isEmpty())
+                .map(stack -> getJEIStackClickable(stack, x, y, w, h))
+                .collect(Collectors.toList());
+    }
+
+    public static List<ClickableIngredient<FluidStack>> toJeiIngredientClickable(FluidEntryList list, int x, int y, int w, int h) {
+        return list.getStacks()
+                .stream()
+                .filter(stack -> !stack.isEmpty())
+                .map(stack -> getJEIStackClickable(stack, x, y, w, h))
+                .toList();
+    }
+}