@adeficior/data-modifier-recipes 2.0.0-rc.20260814115618

package/src/serializer/vanilla/stonecutting.ts

@@ -0,0 +1,63 @@
+import {
+  type Ingredient,
+  type Result,
+} from "@adeficior/data-modifier-ingredients";
+import { type RecipeDefinition } from "../../schema";
+import { Recipe, RecipeParser } from "../abstract";
+import { type RecipeParseContext } from "../context";
+import { type RecipeModifier } from "../modifier";
+
+export type StonecuttingRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    ingredient: unknown;
+    result: unknown;
+    count?: number;
+  }>;
+
+// TODO could also be SmeltingRecipe?
+export class StonecuttingRecipe extends Recipe {
+  constructor(
+    private readonly ingredient: Ingredient,
+    private readonly result: Result,
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return [this.ingredient];
+  }
+
+  getResults() {
+    return [this.result];
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new StonecuttingRecipe(
+      modifier.ingredient(this.ingredient),
+      modifier.result(this.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<StonecuttingRecipeDefinition> {
+    return {
+      ingredient: context.ingredients.serialize(this.ingredient),
+      result: context.results.serialize(this.result),
+    };
+  }
+}
+
+export class StonecuttingParser extends RecipeParser<
+  StonecuttingRecipeDefinition,
+  StonecuttingRecipe
+> {
+  deserialize(
+    definition: StonecuttingRecipeDefinition,
+    context: RecipeParseContext,
+  ): StonecuttingRecipe {
+    const ingredient = context.ingredients.deserialize(definition.ingredient);
+    const result = context.results.deserialize(definition.result);
+    return new StonecuttingRecipe(ingredient, result);
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1 @@
+export * from "./setup";

package/src/testing/setup.ts

@@ -0,0 +1,85 @@
+import { packFormatOf, type EventHandler } from "@adeficior/data-modifier-core";
+import {
+  setupIngredientSerializer,
+  setupPredicates,
+  setupResultSerializer,
+} from "@adeficior/data-modifier-ingredients/testing";
+import { setupTagRegistry } from "@adeficior/data-modifier-tags/testing";
+import { createTestLogger } from "@adeficior/pack-resolver/testing";
+import { createTestDataResolver, setupLookup } from "@adeficior/testing";
+import { afterAll, afterEach, beforeAll } from "bun:test";
+import { RecipeEmitter } from "../emitter";
+import { type RegisterRecipeParser } from "../hooks";
+import { RecipeLoader } from "../loader";
+import { recipePattern } from "../schema";
+
+// TODO move to testing package?
+export function setupRecipeLoader(
+  version: string,
+  parsers?: EventHandler<RegisterRecipeParser>,
+  mods: string[] = [],
+) {
+  const lookup = setupLookup(version);
+
+  const results = setupResultSerializer(version, lookup);
+  const ingredients = setupIngredientSerializer(version, lookup);
+
+  const loader = new RecipeLoader(results, ingredients, {
+    mods: ["minecraft", ...mods],
+  });
+  const logger = createTestLogger();
+
+  beforeAll(async () => {
+    await parsers?.({
+      register: (...args) => loader.registerParser(...args),
+    });
+
+    const resolver = await createTestDataResolver(version, {
+      include: recipePattern(packFormatOf(version)),
+      logger,
+    });
+    //  TODO use distribute for this somehow
+    await resolver.extract(loader);
+  });
+
+  afterAll(() => {
+    logger.reset();
+  });
+
+  return { loader, logger };
+}
+
+export function setupRecipeEmitter(
+  version: string,
+  parsers?: EventHandler<RegisterRecipeParser>,
+  mods: string[] = ["minecraft"],
+) {
+  const lookup = setupLookup(version);
+
+  const results = setupResultSerializer(version, lookup);
+  const ingredients = setupIngredientSerializer(version, lookup);
+  const tags = setupTagRegistry(version);
+  const predicates = setupPredicates(lookup, tags, ingredients);
+
+  const logger = createTestLogger();
+  const { loader } = setupRecipeLoader(version, parsers, mods);
+
+  const emitter = new RecipeEmitter(
+    logger,
+    packFormatOf(version),
+    loader,
+    results,
+    ingredients,
+    predicates,
+    loader,
+  );
+
+  const resolver = emitter.resolver({ logger });
+
+  afterEach(() => {
+    emitter.clear();
+    logger.reset();
+  });
+
+  return { loader, emitter, resolver, logger };
+}

package/test/1.20.1/__snapshots__/emitter.test.ts.snap

@@ -0,0 +1,122 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`recipe ingredient replacement replaces ingredients: modified piston recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:cobblestone/normal",
+    },
+    "R": {
+      "item": "minecraft:emerald",
+    },
+    "T": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "tag": "forge:ingots/iron",
+    },
+  },
+  "pattern": [
+    "TTT",
+    "#X#",
+    "#R#",
+  ],
+  "result": {
+    "item": "minecraft:piston",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients: modified compass recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:ingots/iron",
+    },
+    "X": {
+      "item": "minecraft:emerald",
+    },
+  },
+  "pattern": [
+    " # ",
+    "#X#",
+    " # ",
+  ],
+  "result": {
+    "item": "minecraft:compass",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients: recipes including redstone as an ingredient 1`] = `
+[
+  "data/minecraft/recipes/clock.json",
+  "data/minecraft/recipes/compass.json",
+  "data/minecraft/recipes/detector_rail.json",
+  "data/minecraft/recipes/dispenser.json",
+  "data/minecraft/recipes/dropper.json",
+  "data/minecraft/recipes/note_block.json",
+  "data/minecraft/recipes/observer.json",
+  "data/minecraft/recipes/piston.json",
+  "data/minecraft/recipes/powered_rail.json",
+  "data/minecraft/recipes/redstone_block.json",
+  "data/minecraft/recipes/redstone_lamp.json",
+  "data/minecraft/recipes/redstone_torch.json",
+  "data/minecraft/recipes/repeater.json",
+  "data/minecraft/recipes/target.json",
+]
+`;
+
+exports[`recipe ingredient replacement replaces ingredients with additional input filter: modified piston recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:cobblestone/normal",
+    },
+    "R": {
+      "item": "minecraft:emerald",
+    },
+    "T": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "tag": "forge:ingots/iron",
+    },
+  },
+  "pattern": [
+    "TTT",
+    "#X#",
+    "#R#",
+  ],
+  "result": {
+    "item": "minecraft:piston",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients with additional input filter: modified note_block recipe 1`] = `
+{
+  "category": "redstone",
+  "key": {
+    "#": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "item": "minecraft:emerald",
+    },
+  },
+  "pattern": [
+    "###",
+    "#X#",
+    "###",
+  ],
+  "result": {
+    "item": "minecraft:note_block",
+  },
+  "show_notification": true,
+  "type": "minecraft:crafting_shaped",
+}
+`;

package/test/1.20.1/__snapshots__/loader.test.ts.snap

@@ -0,0 +1,215 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`recipe ingredient replacement replaces ingredients: modified piston recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:cobblestone/normal",
+    },
+    "R": {
+      "item": "minecraft:emerald",
+    },
+    "T": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "tag": "forge:ingots/iron",
+    },
+  },
+  "pattern": [
+    "TTT",
+    "#X#",
+    "#R#",
+  ],
+  "result": {
+    "item": "minecraft:piston",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients: modified compass recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:ingots/iron",
+    },
+    "X": {
+      "item": "minecraft:emerald",
+    },
+  },
+  "pattern": [
+    " # ",
+    "#X#",
+    " # ",
+  ],
+  "result": {
+    "item": "minecraft:compass",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients: recipes including redstone as an ingredient 1`] = `
+[
+  "data/botania/recipes/brew/speed.json",
+  "data/botania/recipes/brew/weak_regeneration.json",
+  "data/botania/recipes/detector_light_relay.json",
+  "data/botania/recipes/ender_eye_block.json",
+  "data/botania/recipes/hourglass.json",
+  "data/botania/recipes/lens_mine.json",
+  "data/botania/recipes/mana_detector.json",
+  "data/botania/recipes/mana_infusion/mana_powder_dust.json",
+  "data/botania/recipes/mana_infusion/redstone_dupe.json",
+  "data/botania/recipes/mana_infusion/redstone_to_glowstone_dust.json",
+  "data/botania/recipes/pattern_1_1.json",
+  "data/botania/recipes/pattern_1_2.json",
+  "data/botania/recipes/pattern_1_3.json",
+  "data/botania/recipes/pattern_2_1.json",
+  "data/botania/recipes/pattern_2_2.json",
+  "data/botania/recipes/pattern_2_3.json",
+  "data/botania/recipes/pattern_3_1.json",
+  "data/botania/recipes/pattern_3_2.json",
+  "data/botania/recipes/pattern_donut.json",
+  "data/botania/recipes/quartz_red.json",
+  "data/botania/recipes/red_pavement.json",
+  "data/botania/recipes/redstone_root.json",
+  "data/botania/recipes/redstone_spreader.json",
+  "data/botania/recipes/spark_changer.json",
+  "data/botania/recipes/unholy_cloak.json",
+  "data/minecraft/recipes/clock.json",
+  "data/minecraft/recipes/compass.json",
+  "data/minecraft/recipes/detector_rail.json",
+  "data/minecraft/recipes/dispenser.json",
+  "data/minecraft/recipes/dropper.json",
+  "data/minecraft/recipes/note_block.json",
+  "data/minecraft/recipes/observer.json",
+  "data/minecraft/recipes/piston.json",
+  "data/minecraft/recipes/powered_rail.json",
+  "data/minecraft/recipes/redstone_block.json",
+  "data/minecraft/recipes/redstone_lamp.json",
+  "data/minecraft/recipes/redstone_torch.json",
+  "data/minecraft/recipes/repeater.json",
+  "data/minecraft/recipes/target.json",
+]
+`;
+
+exports[`recipe ingredient replacement replaces ingredients with additional input filter: modified piston recipe 1`] = `
+{
+  "key": {
+    "#": {
+      "tag": "forge:cobblestone/normal",
+    },
+    "R": {
+      "item": "minecraft:emerald",
+    },
+    "T": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "tag": "forge:ingots/iron",
+    },
+  },
+  "pattern": [
+    "TTT",
+    "#X#",
+    "#R#",
+  ],
+  "result": {
+    "item": "minecraft:piston",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients with additional input filter: modified note_block recipe 1`] = `
+{
+  "category": "redstone",
+  "key": {
+    "#": {
+      "tag": "minecraft:planks",
+    },
+    "X": {
+      "item": "minecraft:emerald",
+    },
+  },
+  "pattern": [
+    "###",
+    "#X#",
+    "###",
+  ],
+  "result": {
+    "item": "minecraft:note_block",
+  },
+  "show_notification": true,
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients in create recipes: modified create:raw_zinc_block recipe 1`] = `
+{
+  "key": {
+    "C": {
+      "tag": "forge:raw_materials/iron",
+    },
+  },
+  "pattern": [
+    "CCC",
+    "CCC",
+    "CCC",
+  ],
+  "result": {
+    "item": "create:raw_zinc_block",
+  },
+  "type": "minecraft:crafting_shaped",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients in create recipes: modified create:raw_zinc recipe 1`] = `
+{
+  "ingredients": [
+    {
+      "tag": "forge:raw_materials/iron",
+    },
+  ],
+  "processingTime": 400,
+  "results": [
+    {
+      "item": "create:crushed_raw_zinc",
+    },
+    {
+      "chance": 0.75,
+      "item": "create:experience_nugget",
+    },
+  ],
+  "type": "create:crushing",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients in create recipes: modified create:zinc_ingot_from_raw_ore recipe 1`] = `
+{
+  "cookingtime": 100,
+  "experience": 0.7,
+  "ingredient": {
+    "tag": "forge:raw_materials/iron",
+  },
+  "result": {
+    "item": "create:zinc_ingot",
+  },
+  "type": "minecraft:blasting",
+}
+`;
+
+exports[`recipe ingredient replacement replaces ingredients in create recipes: modified create:zinc_ingot_from_raw_ore recipe 2`] = `
+{
+  "cookingtime": 200,
+  "experience": 0.7,
+  "ingredient": {
+    "tag": "forge:raw_materials/iron",
+  },
+  "result": {
+    "item": "create:zinc_ingot",
+  },
+  "type": "minecraft:smelting",
+}
+`;

package/test/1.20.1/emitter.test.ts

@@ -0,0 +1,222 @@
+import { type NormalizedId } from "@adeficior/data-modifier-core";
+import {
+  ItemIngredient,
+  ItemResult,
+} from "@adeficior/data-modifier-ingredients";
+import { createTestAcceptor } from "@adeficior/pack-resolver/testing";
+import { describe, expect, it } from "bun:test";
+import { basename } from "node:path";
+import {
+  type RecipeTest,
+  type ShapedRecipeDefinition,
+  EMPTY_RECIPE,
+} from "../../src";
+import { setupRecipeEmitter } from "../../src/testing";
+
+const version = basename(import.meta.dir);
+const { emitter, resolver, logger } = setupRecipeEmitter(version);
+
+describe("recipe ingredient replacement", () => {
+  it("replaces ingredients", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.replaceIngredient(
+      "minecraft:redstone",
+      new ItemIngredient("minecraft:emerald"),
+    );
+
+    await resolver.extract(acceptor);
+
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/piston.json"),
+    ).toMatchSnapshot("modified piston recipe");
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/compass.json"),
+    ).toMatchSnapshot("modified compass recipe");
+
+    expect(acceptor.paths()).toMatchSnapshot(
+      "recipes including redstone as an ingredient",
+    );
+  });
+
+  it("replaces ingredients with additional input filter", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.replaceIngredient(
+      "minecraft:redstone",
+      new ItemIngredient("minecraft:emerald"),
+      {
+        input: "#minecraft:planks",
+      },
+    );
+
+    await resolver.extract(acceptor);
+
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/piston.json"),
+    ).toMatchSnapshot("modified piston recipe");
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/note_block.json"),
+    ).toMatchSnapshot("modified note_block recipe");
+    expect(acceptor.jsonAt("data/minecraft/recipes/compass.json")).toBeNull();
+  });
+
+  it("matches recipes wrapped in forge:conditional", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.remove({
+      input: new ItemIngredient("minecraft:poppy"),
+      type: "minecraft:crafting_shapeless",
+    });
+
+    await resolver.extract(acceptor);
+
+    expect(
+      acceptor.jsonAt("data/custom/recipes/conditional.json"),
+    ).toMatchObject(EMPTY_RECIPE);
+  });
+});
+
+describe("recipe removal", () => {
+  it("removes recipes with id filter", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.remove({
+      id: /minecraft:.*piston/,
+    });
+
+    await resolver.extract(acceptor);
+
+    expect(acceptor.paths()).toHaveLength(2);
+
+    expect(acceptor.jsonAt("data/minecraft/recipes/piston.json")).toMatchObject(
+      EMPTY_RECIPE,
+    );
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/sticky_piston.json"),
+    ).toMatchObject(EMPTY_RECIPE);
+  });
+
+  it("removes recipes with type filter", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.remove({
+      type: "minecraft:smelting",
+    });
+
+    await resolver.extract(acceptor);
+
+    expect(acceptor.paths()).toHaveLength(70);
+  });
+
+  it("removes recipes with result filter", async () => {
+    const acceptor = createTestAcceptor();
+
+    emitter.remove({
+      output: "minecraft:cooked_beef",
+    });
+
+    await resolver.extract(acceptor);
+
+    expect(acceptor.paths()).toHaveLength(3);
+
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/cooked_beef.json"),
+    ).toMatchObject(EMPTY_RECIPE);
+    expect(
+      acceptor.jsonAt("data/minecraft/recipes/cooked_beef_from_smoking.json"),
+    ).toMatchObject(EMPTY_RECIPE);
+    expect(
+      acceptor.jsonAt(
+        "data/minecraft/recipes/cooked_beef_from_campfire_cooking.json",
+      ),
+    ).toMatchObject(EMPTY_RECIPE);
+  });
+});
+
+it("creates custom recipes", async () => {
+  const acceptor = createTestAcceptor();
+
+  const recipe: ShapedRecipeDefinition = {
+    type: "minecraft:shaped",
+    key: {
+      A: {
+        item: "minecraft:diamond",
+      },
+      B: {
+        tag: "minecraft:iron_ores",
+      },
+    },
+    result: {
+      item: "minecraft:command_block",
+    },
+    pattern: ["A ", " B"],
+  };
+
+  emitter.add("example:custom", recipe);
+
+  await resolver.extract(acceptor);
+
+  expect(acceptor.jsonAt("data/example/recipes/custom.json")).toMatchObject(
+    recipe,
+  );
+});
+
+it("warns about duplicate custom recipe IDs", () => {
+  const id: NormalizedId = "example:recipe";
+
+  emitter.add(id, { type: "example:something" });
+  emitter.add(id, { type: "example:something_else" });
+
+  expect(logger.error).toHaveBeenCalledWith(
+    `Overwriting custom recipe with ID ${id}`,
+  );
+});
+
+it("warns about missing recipe removal matches", async () => {
+  const test: RecipeTest = {
+    type: "example:not_existing",
+  };
+
+  emitter.remove(test);
+
+  const acceptor = createTestAcceptor();
+  await resolver.extract(acceptor);
+
+  expect(logger.trace).toHaveBeenCalledWith(
+    "could not find any recipes matching",
+    expect.objectContaining({
+      operation: "remove",
+      test,
+    }),
+  );
+});
+
+it("warns about missing recipe replacement matches", async () => {
+  const from = "minecraft:bedrock";
+  const to = new ItemResult("minecraft:dirt");
+  emitter.replaceResult(from, to);
+
+  const acceptor = createTestAcceptor();
+  await resolver.extract(acceptor);
+
+  expect(logger.trace).toHaveBeenCalledWith(
+    "could not find any recipes matching",
+    expect.objectContaining({
+      operation: "replace result",
+      from,
+      to,
+    }),
+  );
+});
+
+it("does not warn about optional missing recipe matches", async () => {
+  const from = "minecraft:bedrock";
+  const to = new ItemResult("minecraft:dirt");
+  emitter.replaceResult(from, to, { optional: true });
+
+  const acceptor = createTestAcceptor();
+  await resolver.extract(acceptor);
+
+  expect(logger.error).not.toHaveBeenCalled();
+});