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

package/src/rule.ts

@@ -0,0 +1,45 @@
+import {
+  createId,
+  Rule,
+  type Id,
+  type Modifier,
+} from "@adeficior/data-modifier-core";
+import { type Predicate } from "@adeficior/data-modifier-core/serializer";
+import {
+  type Ingredient,
+  type Result,
+} from "@adeficior/data-modifier-ingredients";
+import { type ContextLike, type Logger } from "@adeficior/pack-resolver";
+import { type RecipeHolder } from "./serializer/holder";
+
+export class RecipeRule extends Rule<RecipeHolder> {
+  constructor(
+    private readonly context: ContextLike,
+    private readonly idsTests: Predicate<Id>[],
+    private readonly typeTests: Predicate<Id>[],
+    private readonly ingredientTests: Predicate<Ingredient>[],
+    private readonly resultTests: Predicate<Result>[],
+    modifier: Modifier<RecipeHolder>,
+  ) {
+    super(modifier);
+  }
+
+  matches(id: Id, recipe: RecipeHolder): boolean {
+    const types = recipe.getTypes().map(createId);
+
+    return (
+      this.idsTests.every((test) => test(id)) &&
+      this.typeTests.every((test) => types.some((it) => test(it))) &&
+      this.ingredientTests.every((test) =>
+        recipe.getIngredients().some((it) => test(it)),
+      ) &&
+      this.resultTests.every((test) =>
+        recipe.getResults().some((it) => test(it)),
+      )
+    );
+  }
+
+  printWarning(logger: Logger) {
+    logger.trace("could not find any recipes matching", this.context);
+  }
+}

package/src/schema.ts

@@ -0,0 +1,30 @@
+import {
+  createId,
+  isAtLeastVersion,
+  jsonFilePattern,
+  type IdInput,
+  type SemVerInput,
+  type WithConditions,
+} from "@adeficior/data-modifier-core";
+import { type RecipeSerializerId } from "@adeficior/data-modifier/generated";
+
+export type RecipeDefinition = WithConditions<
+  Readonly<{
+    type: RecipeSerializerId;
+    // TODO add neoforge conditions
+  }>
+>;
+
+function recipeFolder(packFormat: SemVerInput) {
+  return isAtLeastVersion(packFormat, "44") ? "recipe" : "recipes";
+}
+
+export function recipePath(packFormat: SemVerInput, id: IdInput) {
+  const folder = recipeFolder(packFormat);
+  const { namespace, path } = createId(id);
+  return `data/${namespace}/${folder}/${path}.json`;
+}
+
+export function recipePattern(packFormat: SemVerInput) {
+  return jsonFilePattern("data", recipeFolder(packFormat));
+}

package/src/serializer/abstract.ts

@@ -0,0 +1,41 @@
+import { type NormalizedId } from "@adeficior/data-modifier-core";
+import {
+  type Ingredient,
+  type Result,
+  type WithSerializerModules,
+} from "@adeficior/data-modifier-ingredients";
+import { type RecipeDefinition } from "../schema";
+import { type RecipeParseContext } from "./context";
+import { type RecipeModifier } from "./modifier";
+
+export abstract class Recipe {
+  abstract getIngredients(): Ingredient[];
+
+  abstract getResults(): Result[];
+
+  abstract modify(modifier: RecipeModifier): Recipe;
+
+  additionalTypes(): NormalizedId[] {
+    return [];
+  }
+
+  abstract serialize(context: RecipeParseContext): Partial<RecipeDefinition>;
+}
+
+export abstract class RecipeParser<
+  TDefinition extends RecipeDefinition = RecipeDefinition,
+  TRecipe extends Recipe = Recipe,
+> implements WithSerializerModules {
+  ingredientModules() {
+    return {};
+  }
+
+  resultModules() {
+    return {};
+  }
+
+  abstract deserialize(
+    definition: TDefinition,
+    context: RecipeParseContext,
+  ): TRecipe;
+}

package/src/serializer/context.ts

@@ -0,0 +1,17 @@
+import {
+  type IngredientSerializer,
+  type ResultSerializer,
+} from "@adeficior/data-modifier-ingredients";
+import { type RecipeDefinition } from "../schema";
+import { type RecipeHolder } from "./holder";
+
+export type RecipeSerializer = {
+  deserialize(definition: RecipeDefinition): RecipeHolder;
+  serialize(recipe: RecipeHolder): RecipeDefinition;
+};
+
+export type RecipeParseContext = {
+  results: ResultSerializer;
+  ingredients: IngredientSerializer;
+  recipes: RecipeSerializer;
+};

package/src/serializer/forge/conditional.ts

@@ -0,0 +1,72 @@
+import { type RecipeDefinition } from "../../schema";
+import { Recipe, RecipeParser } from "../abstract";
+import { type RecipeParseContext } from "../context";
+import { type RecipeHolder } from "../holder";
+import { type RecipeModifier } from "../modifier";
+
+type WithConditions<T> = {
+  conditions: unknown[];
+  recipe: T;
+};
+
+export type ForgeConditionalRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    recipes: WithConditions<RecipeDefinition>[];
+  }>;
+
+export class ForgeConditionalRecipe extends Recipe {
+  constructor(private readonly recipes: WithConditions<RecipeHolder>[]) {
+    super();
+  }
+
+  getIngredients() {
+    return this.recipes.flatMap((it) => it.recipe.getIngredients());
+  }
+
+  getResults() {
+    return this.recipes.flatMap((it) => it.recipe.getResults());
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new ForgeConditionalRecipe(
+      this.recipes.map((it) => ({
+        ...it,
+        recipe: it.recipe.modify(modifier),
+      })),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<ForgeConditionalRecipeDefinition> {
+    return {
+      recipes: this.recipes.map((it) => ({
+        ...it,
+        recipe: context.recipes.serialize(it.recipe),
+      })),
+    };
+  }
+
+  override additionalTypes() {
+    return this.recipes.flatMap((it) => it.recipe.getTypes());
+  }
+}
+
+export class ForgeConditionalRecipeParser extends RecipeParser<
+  ForgeConditionalRecipeDefinition,
+  ForgeConditionalRecipe
+> {
+  override deserialize(
+    definition: ForgeConditionalRecipeDefinition,
+    context: RecipeParseContext,
+  ): ForgeConditionalRecipe {
+    const recipes = definition.recipes.map<WithConditions<RecipeHolder>>(
+      (it) => ({
+        conditions: it.conditions,
+        recipe: context.recipes.deserialize(it.recipe),
+      }),
+    );
+
+    return new ForgeConditionalRecipe(recipes);
+  }
+}

package/src/serializer/holder.ts

@@ -0,0 +1,63 @@
+import { encodeId, type NormalizedId } from "@adeficior/data-modifier-core";
+import { type Replacer } from "@adeficior/data-modifier-core/serializer";
+import {
+  type Ingredient,
+  type Result,
+} from "@adeficior/data-modifier-ingredients";
+import { type RecipeDefinition } from "../schema";
+import { type Recipe } from "./abstract";
+import { type RecipeParseContext } from "./context";
+import { type RecipeModifier } from "./modifier";
+
+function keep<T>(): Replacer<T> {
+  return (it) => it;
+}
+
+export class RecipeHolder {
+  readonly serializerType: NormalizedId;
+
+  constructor(
+    private readonly definition: RecipeDefinition,
+    private readonly recipe: Recipe,
+  ) {
+    this.serializerType = encodeId(definition.type);
+  }
+
+  serialize(context: RecipeParseContext) {
+    return {
+      ...this.definition,
+      ...this.recipe.serialize(context),
+    };
+  }
+
+  getIngredients() {
+    return this.recipe.getIngredients();
+  }
+
+  getResults() {
+    return this.recipe.getResults();
+  }
+
+  modify(modifier: RecipeModifier): RecipeHolder {
+    const modified = this.recipe.modify(modifier);
+    return new RecipeHolder(this.definition, modified);
+  }
+
+  replaceIngredient(replace: Replacer<Ingredient>): RecipeHolder {
+    return this.modify({
+      ingredient: replace,
+      result: keep(),
+    });
+  }
+
+  replaceResult(replace: Replacer<Result>): RecipeHolder {
+    return this.modify({
+      ingredient: keep(),
+      result: replace,
+    });
+  }
+
+  getTypes(): NormalizedId[] {
+    return [this.serializerType, ...this.recipe.additionalTypes()];
+  }
+}

package/src/serializer/manyToMany.ts

@@ -0,0 +1,62 @@
+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 ManyToManyRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    ingredients: unknown[];
+    results: unknown[];
+  }>;
+
+export class ManyToManyRecipe extends Recipe {
+  constructor(
+    protected readonly ingredients: Ingredient[],
+    protected readonly results: Result[],
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return this.ingredients;
+  }
+
+  getResults() {
+    return this.results;
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new ManyToManyRecipe(
+      this.ingredients.map(modifier.ingredient),
+      this.results.map(modifier.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<ManyToManyRecipeDefinition> {
+    return {
+      results: context.results.serializeList(this.results),
+      ingredients: context.ingredients.serializeList(this.ingredients),
+    };
+  }
+}
+
+export class ManyToManyRecipeParser<
+  TDefinition extends ManyToManyRecipeDefinition,
+> extends RecipeParser<TDefinition, ManyToManyRecipe> {
+  deserialize(
+    definition: TDefinition,
+    context: RecipeParseContext,
+  ): ManyToManyRecipe {
+    const ingredients = context.ingredients.deserializeList(
+      definition.ingredients,
+    );
+    const results = context.results.deserializeList(definition.results);
+    return new ManyToManyRecipe(ingredients, results);
+  }
+}

package/src/serializer/manyToOne.ts

@@ -0,0 +1,62 @@
+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 ManyToOneRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    ingredients: unknown[];
+    result: unknown;
+  }>;
+
+export class ManyToOneRecipe extends Recipe {
+  constructor(
+    protected readonly ingredients: Ingredient[],
+    protected readonly result: Result,
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return this.ingredients;
+  }
+
+  getResults() {
+    return [this.result];
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new ManyToOneRecipe(
+      this.ingredients.map(modifier.ingredient),
+      modifier.result(this.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<ManyToOneRecipeDefinition> {
+    return {
+      result: context.results.serialize(this.result),
+      ingredients: context.ingredients.serializeList(this.ingredients),
+    };
+  }
+}
+
+export class ManyToOneRecipeParser<
+  TDefinition extends ManyToOneRecipeDefinition,
+> extends RecipeParser<TDefinition, ManyToOneRecipe> {
+  deserialize(
+    definition: TDefinition,
+    context: RecipeParseContext,
+  ): ManyToOneRecipe {
+    const ingredients = context.ingredients.deserializeList(
+      definition.ingredients,
+    );
+    const result = context.results.deserialize(definition.result);
+    return new ManyToOneRecipe(ingredients, result);
+  }
+}

package/src/serializer/modifier.ts

@@ -0,0 +1,10 @@
+import { type Replacer } from "@adeficior/data-modifier-core/serializer";
+import {
+  type Ingredient,
+  type Result,
+} from "@adeficior/data-modifier-ingredients";
+
+export type RecipeModifier = {
+  result: Replacer<Result>;
+  ingredient: Replacer<Ingredient>;
+};

package/src/serializer/oneToOne.ts

@@ -0,0 +1,60 @@
+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 OneToOneRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    ingredient: unknown;
+    result: unknown;
+  }>;
+
+export class OneToOneRecipe extends Recipe {
+  constructor(
+    protected readonly ingredient: Ingredient,
+    protected readonly result: Result,
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return [this.ingredient];
+  }
+
+  getResults() {
+    return [this.result];
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new OneToOneRecipe(
+      modifier.ingredient(this.ingredient),
+      modifier.result(this.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<OneToOneRecipeDefinition> {
+    return {
+      result: context.results.serialize(this.result),
+      ingredient: context.ingredients.serialize(this.ingredient),
+    };
+  }
+}
+
+export class OneToOneRecipeParser<
+  TDefinition extends OneToOneRecipeDefinition,
+> extends RecipeParser<TDefinition, OneToOneRecipe> {
+  deserialize(
+    definition: TDefinition,
+    context: RecipeParseContext,
+  ): OneToOneRecipe {
+    const ingredient = context.ingredients.deserialize(definition.ingredient);
+    const result = context.results.deserialize(definition.result);
+    return new OneToOneRecipe(ingredient, result);
+  }
+}

package/src/serializer/vanilla/shaped.ts

@@ -0,0 +1,65 @@
+import {
+  type IngredientMap,
+  type IngredientMapInput,
+  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 ShapedRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    key: IngredientMapInput;
+    pattern: string[];
+    result: unknown;
+  }>;
+
+export class ShapedRecipe extends Recipe {
+  constructor(
+    private readonly ingredients: IngredientMap,
+    private readonly result: Result,
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return this.ingredients.list();
+  }
+
+  getResults() {
+    return [this.result];
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new ShapedRecipe(
+      this.ingredients.replace(modifier.ingredient),
+      modifier.result(this.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<ShapedRecipeDefinition> {
+    return {
+      key: context.ingredients.serializeIngredientMap(this.ingredients),
+      result: context.results.serialize(this.result),
+    };
+  }
+}
+
+export class ShapedParser extends RecipeParser<
+  ShapedRecipeDefinition,
+  ShapedRecipe
+> {
+  deserialize(
+    definition: ShapedRecipeDefinition,
+    context: RecipeParseContext,
+  ): ShapedRecipe {
+    const ingredients = context.ingredients.deserializeIngredientMap(
+      definition.key,
+    );
+    const result = context.results.deserialize(definition.result);
+    return new ShapedRecipe(ingredients, result);
+  }
+}

package/src/serializer/vanilla/shapeless.ts

@@ -0,0 +1,8 @@
+import {
+  ManyToOneRecipeParser,
+  type ManyToOneRecipeDefinition,
+} from "../manyToOne";
+
+export type ShapelessRecipeDefinition = ManyToOneRecipeDefinition;
+
+export class ShapelessParser extends ManyToOneRecipeParser<ShapelessRecipeDefinition> {}

package/src/serializer/vanilla/smelting.ts

@@ -0,0 +1,62 @@
+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 SmeltingRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    ingredient: unknown;
+    result: unknown;
+    experience?: number;
+  }>;
+
+export class SmeltingRecipe 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 SmeltingRecipe(
+      modifier.ingredient(this.ingredient),
+      modifier.result(this.result),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<SmeltingRecipeDefinition> {
+    return {
+      ingredient: context.ingredients.serialize(this.ingredient),
+      result: context.results.serialize(this.result),
+    };
+  }
+}
+
+export class SmeltingParser extends RecipeParser<
+  SmeltingRecipeDefinition,
+  SmeltingRecipe
+> {
+  deserialize(
+    definition: SmeltingRecipeDefinition,
+    context: RecipeParseContext,
+  ): SmeltingRecipe {
+    const ingredient = context.ingredients.deserialize(definition.ingredient);
+    const result = context.results.deserialize(definition.result);
+    return new SmeltingRecipe(ingredient, result);
+  }
+}

package/src/serializer/vanilla/smithing.ts

@@ -0,0 +1,74 @@
+import {
+  type Ingredient,
+  type Result,
+} from "@adeficior/data-modifier-ingredients";
+import { notNull } from "@adeficior/pack-resolver";
+import { type RecipeDefinition } from "../../schema";
+import { Recipe, RecipeParser } from "../abstract";
+import { type RecipeParseContext } from "../context";
+import { type RecipeModifier } from "../modifier";
+
+export type SmithingRecipeDefinition = RecipeDefinition &
+  Readonly<{
+    base: unknown;
+    addition: unknown;
+    result?: unknown;
+    template?: unknown;
+  }>;
+
+export class SmithingRecipe extends Recipe {
+  constructor(
+    private readonly base: Ingredient,
+    private readonly addition: Ingredient,
+    private readonly result: Result | undefined,
+    private readonly template: Ingredient | undefined,
+  ) {
+    super();
+  }
+
+  getIngredients() {
+    return [this.base, this.addition, this.template].filter(notNull);
+  }
+
+  getResults() {
+    return [this.result].filter(notNull);
+  }
+
+  override modify(modifier: RecipeModifier) {
+    return new SmithingRecipe(
+      modifier.ingredient(this.base),
+      modifier.ingredient(this.addition),
+      this.result && modifier.result(this.result),
+      this.template && modifier.ingredient(this.template),
+    );
+  }
+
+  override serialize(
+    context: RecipeParseContext,
+  ): Partial<SmithingRecipeDefinition> {
+    return {
+      base: context.ingredients.serialize(this.base),
+      addition: context.ingredients.serialize(this.addition),
+      result: context.results.serializeOptional(this.result),
+      template: context.ingredients.serializeOptional(this.template),
+    };
+  }
+}
+
+export class SmithingParser extends RecipeParser<
+  SmithingRecipeDefinition,
+  SmithingRecipe
+> {
+  deserialize(
+    definition: SmithingRecipeDefinition,
+    context: RecipeParseContext,
+  ): SmithingRecipe {
+    const base = context.ingredients.deserialize(definition.base);
+    const addition = context.ingredients.deserialize(definition.addition);
+    const result = context.results.deserializeOptional(definition.result);
+    const template = context.ingredients.deserializeOptional(
+      definition.addition,
+    );
+    return new SmithingRecipe(base, addition, result, template);
+  }
+}