@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

package/src/lib/alloy/alloy.test.ts

@@ -1,186 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { parseAlloyPercent, toAlloyRecipe } from './parse';
-import {
-  INGOT_MB,
-  checkMix,
-  ingotRatioMix,
-  minShareMix,
-  minimalAdditions,
-  scaleAmounts,
-  snapToIngots,
-  suggestAmounts,
-} from './mix';
-import { parseRecipe } from '@terrafirmagreg-team/recipe/lib/data/parse/index';
-import type { RecipeSlotFill } from '@terrafirmagreg-team/recipe/lib/data/dto';
-import type { AlloyComponent } from '@terrafirmagreg-team/recipe/types/alloy';
-
-const component = (
-  amount: number,
-  range?: { min: number; max: number },
-): AlloyComponent => ({
-  slot: { amount, id: `test:m${amount}`, ref: { kind: 'fluid', id: `test:m${amount}` } } as RecipeSlotFill,
-  ...(range ? { range } : {}),
-});
-
-test('matches multi-row alloy ranges in reading order', () => {
-  const raw = {
-    category: 'tfc:alloying',
-    slots: Object.fromEntries(
-      [1, 1, 3].map((amount, i) => [
-        `input${i}`,
-        {
-          type: 'input',
-          amount,
-          ref: { kind: 'fluid', id: `test:metal${i}` },
-        },
-      ]),
-    ),
-    widgets: [
-      [24, 27, '10-20%'],
-      [90, 27, '20-30%'],
-      [24, 47, '50-65%'],
-    ].map(([x, y, text]) => ({ type: 'text', x, y, text, w: 36, h: 9 })),
-  };
-  const recipe = parseRecipe(raw, {
-    id: 'test:alloy',
-    modId: 'test',
-    bodyUrl: '/test',
-  });
-  assert.ok(recipe);
-  const model = toAlloyRecipe(recipe);
-  assert.deepEqual(
-    model.components.map((row) => row.range?.min),
-    [10, 20, 50],
-  );
-});
-
-test('parses percent ranges from dump text widgets', () => {
-  assert.deepEqual(parseAlloyPercent('§x§0§0§0§0§0§070-85%'), {
-    min: 70,
-    max: 85,
-  });
-  assert.equal(parseAlloyPercent('85-70%'), undefined);
-  assert.equal(parseAlloyPercent('Copper'), undefined);
-});
-
-test('recipe-ratio split scales to a total', () => {
-  const components = [component(4), component(1)];
-  assert.deepEqual(suggestAmounts(components, 100), [80, 20]);
-  assert.equal(suggestAmounts(components, 0), null);
-  assert.equal(suggestAmounts(components, Infinity), null);
-  assert.equal(suggestAmounts([], 100), null);
-});
-
-test('scaleAmounts rescales to a new total keeping proportions', () => {
-  assert.deepEqual(scaleAmounts([60, 40], 200), [120, 80]);
-  assert.deepEqual(scaleAmounts([3, 1], 100), [75, 25]);
-  assert.equal(scaleAmounts([60, 40], 0), null);
-  assert.equal(scaleAmounts([0, 0], 100), null);
-  assert.equal(scaleAmounts([60, 40], Infinity), null);
-});
-
-test('mix check flags out-of-range shares', () => {
-  const components = [
-    component(4, { min: 70, max: 85 }),
-    component(1, { min: 15, max: 30 }),
-  ];
-  const ok = checkMix(components, [80, 20]);
-  assert.equal(ok.valid, true);
-  assert.equal(ok.output, 100);
-  const bad = checkMix(components, [50, 50]);
-  assert.equal(bad.valid, false);
-  assert.equal(bad.rows[0].valid, false);
-  assert.equal(bad.rows[1].valid, false);
-  assert.equal(checkMix(components, [0, 0]).valid, false);
-});
-
-test('recipe ratio renders as whole ingots', () => {
-  const components = [
-    component(9, { min: 88, max: 92 }),
-    component(1, { min: 8, max: 12 }),
-  ];
-  const ratio = ingotRatioMix(components);
-  assert.deepEqual(ratio, { counts: [9, 1], total: 10 });
-  const mix = checkMix(components, ratio!.counts.map((c) => c * INGOT_MB));
-  assert.equal(mix.valid, true);
-});
-
-test('ingot ratio reduces amounts to lowest terms', () => {
-  assert.deepEqual(ingotRatioMix([component(4), component(1)]), {
-    counts: [4, 1],
-    total: 5,
-  });
-  assert.deepEqual(ingotRatioMix([component(700), component(300)]), {
-    counts: [7, 3],
-    total: 10,
-  });
-  assert.deepEqual(ingotRatioMix([component(1.5), component(0.5)]), {
-    counts: [3, 1],
-    total: 4,
-  });
-});
-
-test('ingot ratio is null without usable amounts', () => {
-  assert.equal(ingotRatioMix([]), null);
-  assert.equal(ingotRatioMix([component(0), component(1)]), null);
-});
-
-test('minimal additions restore a valid mix without removing metal', () => {
-  const components = [
-    component(4, { min: 70, max: 85 }),
-    component(1, { min: 15, max: 30 }),
-  ];
-  const add = minimalAdditions(components, [50, 50]);
-  assert.ok(add);
-  assert.equal(add[1], 0);
-  assert.ok(add[0] > 0);
-  const fixed = checkMix(components, [50 + add[0], 50]);
-  assert.equal(fixed.valid, true);
-
-  assert.deepEqual(minimalAdditions(components, [80, 20]), [0, 0]);
-
-  const impossible = minimalAdditions(
-    [component(1, { min: 10, max: 20 }), component(1, { min: 10, max: 20 })],
-    [50, 50],
-  );
-  assert.equal(impossible, null);
-});
-
-test('snapToIngots finds the closest valid whole-ingot mix', () => {
-  const components = [
-    component(9, { min: 88, max: 92 }),
-    component(1, { min: 8, max: 12 }),
-  ];
-
-  assert.deepEqual(snapToIngots(components, [1296, 144]), [1296, 144]);
-
-  assert.deepEqual(snapToIngots(components, [1150, 150]), [1152, 144]);
-
-  assert.equal(snapToIngots(components, [144, 144]), null);
-
-  assert.deepEqual(
-    snapToIngots([component(4), component(1)], [500, 130]),
-    [432, 144],
-  );
-
-  assert.deepEqual(
-    snapToIngots([component(4), component(1)], [432, 0]),
-    [432, 0],
-  );
-});
-
-test('minShareMix pins a metal to its min bound', () => {
-  const components = [
-    component(9, { min: 88, max: 92 }),
-    component(1, { min: 8, max: 12 }),
-  ];
-  const mix = minShareMix(components, 1, 1440);
-  assert.ok(mix);
-  assert.equal(mix[1], Math.ceil((1440 * 8) / 100));
-  assert.equal(mix[0] + mix[1], 1440);
-  assert.equal(checkMix(components, mix).valid, true);
-
-  assert.equal(minShareMix([component(4), component(1)], 0, 100), null);
-  assert.equal(minShareMix(components, 1, 0), null);
-});

package/src/lib/calc/tree/build.ts

@@ -1,196 +0,0 @@
-import type { BuildTreeInput, CalcKind, CalcNode } from '@terrafirmagreg-team/recipe/types/calc';
-import { AUTO_MAX_DEPTH, type BuildContext, type RemainderPool } from './context';
-import { materialKey } from './materials';
-import { calcAutoPick } from './pick';
-import { recipeDivisor } from './recipe';
-
-const MAX_BUILD_DEPTH = 64;
-
-function poolTake(pool: RemainderPool, kind: CalcKind, id: string, want: number) {
-  const key = materialKey(kind, id);
-  const have = pool.get(key) ?? 0;
-  const taken = Math.min(have, want);
-  const left = have - taken;
-  if (left > 0) pool.set(key, left);
-  else pool.delete(key);
-  return taken;
-}
-
-function poolAdd(pool: RemainderPool, kind: CalcKind, id: string, amount: number) {
-  if (amount <= 0) return;
-  const key = materialKey(kind, id);
-  pool.set(key, (pool.get(key) ?? 0) + amount);
-}
-
-function resolveTagMember(ctx: BuildContext, tagId: string) {
-  const tag = ctx.tagMembers(tagId);
-  if (!tag || !tag.members.length) return undefined;
-  const picked = ctx.tagSelections[tagId];
-  const memberId =
-    picked && tag.members.includes(picked) ? picked : tag.members[0]!;
-  return { memberId, members: tag.members, kind: tag.kind };
-}
-
-export function buildTree(input: BuildTreeInput, ctx: BuildContext): CalcNode {
-  const { materialId, kind, amount, depth, tagId, catalyst, consumeChance, path } =
-    input;
-  const matKey = materialKey(kind, materialId);
-  const availableRecipes = ctx.getRecipesForItem(materialId, kind);
-  const tag = tagId ? resolveTagMember(ctx, tagId) : undefined;
-
-  const base: CalcNode = {
-    materialId,
-    kind,
-    amount,
-    satisfied: 0,
-    need: amount,
-    recipe: null,
-    batches: 0,
-    produced: 0,
-    cycle: false,
-    catalyst: catalyst === true,
-    children: [],
-    availableRecipes,
-    depth,
-    ...(path ? { path } : {}),
-    ...(consumeChance !== undefined && consumeChance < 1
-      ? { consumeChance }
-      : {}),
-    ...(tagId ? { tagId, members: tag?.members } : {}),
-  };
-
-  const userCollapsed =
-    path != null && (ctx.collapsed?.has(path) ?? false);
-  const underAuto =
-    path != null &&
-    (ctx.autoRoots?.some(
-      (root) => path === root || path.startsWith(`${root}/`),
-    ) ??
-      false);
-  const auto =
-    underAuto &&
-    depth < AUTO_MAX_DEPTH &&
-    (ctx.autoBudget ? ctx.autoBudget.left-- > 0 : true);
-  const pickOnly = !auto || userCollapsed;
-  let selectedRecipeId = pickOnly
-    ? path
-      ? ctx.selections[path]
-      : undefined
-    : ((path ? ctx.selections[path] : undefined) ??
-      ctx.selections[materialId]);
-  let pickPending = false;
-  if (!availableRecipes.some((row) => row.recipeId === selectedRecipeId)) {
-    if (pickOnly) {
-      selectedRecipeId = undefined;
-    } else {
-      const autoPick = calcAutoPick(
-        availableRecipes,
-        materialId,
-        ctx.usedMaterials,
-        ctx,
-      );
-      selectedRecipeId = autoPick.pick;
-      pickPending = !autoPick.pick;
-    }
-  }
-  const recipe = selectedRecipeId ? ctx.recipeMap.get(selectedRecipeId) : null;
-  base.recipe = recipe ?? null;
-  if (underAuto) base.auto = auto;
-  if (!recipe && !catalyst && availableRecipes.length > 0 && path != null) {
-    if (pickPending) base.loading = true;
-    else base.expandable = true;
-  } else if (
-    !recipe &&
-    !availableRecipes.length &&
-    path != null &&
-    !(ctx.recipesResolved?.(materialId) ?? true)
-  ) {
-    base.loading = true;
-  }
-  if (userCollapsed && !recipe) base.collapsed = true;
-  if (catalyst && !recipe) return base;
-  if (depth >= MAX_BUILD_DEPTH) return base;
-
-  const satisfied = ctx.pool
-    ? poolTake(ctx.pool, kind, materialId, amount)
-    : 0;
-  const need = amount - satisfied;
-  base.satisfied = satisfied;
-  base.need = need;
-  if (need <= 0) return base;
-
-  if (!recipe) return base;
-  if (
-    ctx.used.has(recipe.recipeId) ||
-    ctx.usedMaterials.has(matKey)
-  ) {
-    base.cycle = true;
-    return base;
-  }
-
-  const divisor = recipeDivisor(recipe, materialId, kind);
-  const batches = Math.ceil(need / divisor);
-  const produced = batches * divisor;
-  base.batches = batches;
-  base.produced = produced;
-
-  ctx.used.add(recipe.recipeId);
-  ctx.usedMaterials.add(matKey);
-  for (const inp of recipe.inputs) {
-    if (inp.catalyst) {
-      if (inp.id) {
-        const resolved = inp.tagId
-          ? resolveTagMember(ctx, inp.tagId)?.memberId
-          : undefined;
-        base.children.push(
-          buildTree(
-            {
-              materialId: resolved ?? inp.id,
-              kind: inp.kind,
-              amount: inp.amount,
-              depth: depth + 1,
-              tagId: inp.tagId,
-              catalyst: true,
-              path: path ? `${path}/${base.children.length}` : undefined,
-            },
-            ctx,
-          ),
-        );
-      }
-      continue;
-    }
-
-    const childAmount = inp.amount * batches * (inp.chance ?? 1);
-    if (childAmount <= 0 || !inp.id) continue;
-    const resolved = inp.tagId ? resolveTagMember(ctx, inp.tagId) : undefined;
-    base.children.push(
-      buildTree(
-        {
-          materialId: resolved?.memberId ?? inp.id,
-          kind: resolved?.kind ?? inp.kind,
-          amount: childAmount,
-          depth: depth + 1,
-          tagId: inp.tagId,
-          consumeChance: inp.chance,
-          path: path ? `${path}/${base.children.length}` : undefined,
-        },
-        ctx,
-      ),
-    );
-  }
-  ctx.used.delete(recipe.recipeId);
-  ctx.usedMaterials.delete(matKey);
-
-  poolAdd(ctx.pool, kind, materialId, produced - need);
-  for (const out of recipe.outputs) {
-    if (out.id !== materialId || out.kind !== kind) {
-      poolAdd(
-        ctx.pool,
-        out.kind,
-        out.id,
-        out.amount * batches * (out.chance ?? 1),
-      );
-    }
-  }
-  return base;
-}

package/src/lib/calc/tree/context.ts

@@ -1,42 +0,0 @@
-import type {
-  CalcKind,
-  CalcNode,
-  CalcMaterial,
-  CalcRecipe,
-  CalcRecipeSummary,
-} from '@terrafirmagreg-team/recipe/types/calc';
-
-export type RemainderPool = Map<string, number>;
-
-export type BuildContext = {
-  recipeMap: Map<string, CalcRecipe>;
-  getRecipesForItem: (
-    materialId: string,
-    kind: CalcKind,
-  ) => CalcRecipeSummary[];
-  selections: Record<string, string>;
-  tagSelections: Record<string, string>;
-  tagMembers: (tagId: string) => { members: string[]; kind: CalcKind } | undefined;
-  pool: RemainderPool;
-  used: Set<string>;
-
-  usedMaterials: Set<string>;
-
-  collapsed?: Set<string>;
-
-  autoRoots?: readonly string[];
-
-  autoBudget?: { left: number };
-
-  recipesResolved?: (materialId: string) => boolean;
-
-  deadIds?: ReadonlySet<string>;
-};
-
-export const AUTO_MAX_DEPTH = 32;
-export const AUTO_NODE_BUDGET = 800;
-
-export type CalcGoal = {
-  node: CalcNode;
-  remainders: CalcMaterial[];
-};

package/src/lib/calc/tree/goal.ts

@@ -1,64 +0,0 @@
-import type {
-  CalcKind,
-  CalcMaterial,
-  CalcNode,
-  CalculatorTarget,
-} from '@terrafirmagreg-team/recipe/types/calc';
-import { buildTree } from './build';
-import type { BuildContext, CalcGoal, RemainderPool } from './context';
-import { deduplicateMaterials, mergeAmounts } from './materials';
-
-export function buildGoal(
-  target: CalculatorTarget,
-  ctx: Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'>,
-  path?: string,
-  inventory?: readonly CalcMaterial[],
-): CalcGoal {
-
-  const pool: RemainderPool = new Map();
-  for (const row of inventory ?? []) {
-    if (row.amount > 0) {
-      const key = `${row.kind}:${row.id}`;
-      pool.set(key, (pool.get(key) ?? 0) + row.amount);
-    }
-  }
-  const node = buildTree(
-    {
-      materialId: target.id,
-      kind: target.kind,
-      amount: target.amount,
-      depth: 0,
-      path,
-    },
-    { ...ctx, pool, used: new Set(), usedMaterials: new Set() },
-  );
-  const remainders: CalcMaterial[] = [...pool.entries()].map(([key, amount]) => {
-    const sep = key.indexOf(':');
-    return { kind: key.slice(0, sep) as CalcKind, id: key.slice(sep + 1), amount };
-  });
-  return { node, remainders };
-}
-
-export function flattenTree(node: CalcNode): {
-  cost: CalcMaterial[];
-  catalysts: CalcMaterial[];
-} {
-  const cost: CalcMaterial[] = [];
-  const catalysts: CalcMaterial[] = [];
-
-  function recurse(n: CalcNode) {
-    if (n.catalyst) {
-      catalysts.push({ id: n.materialId, kind: n.kind, amount: n.amount });
-      return;
-    }
-    if (n.need <= 0) return;
-    if (n.recipe === null || n.cycle) {
-      cost.push({ id: n.materialId, kind: n.kind, amount: n.need });
-      return;
-    }
-    for (const child of n.children) recurse(child);
-  }
-
-  recurse(node);
-  return { cost: mergeAmounts(cost), catalysts: deduplicateMaterials(catalysts) };
-}

package/src/lib/calc/tree/ideal.ts

@@ -1,36 +0,0 @@
-import type { CalcNode } from '@terrafirmagreg-team/recipe/types/calc';
-import { recipeDivisor } from './recipe';
-
-const SCALE = 1000;
-const CAP = 1_000_000;
-
-function gcd(a: number, b: number): number {
-  a = Math.round(Math.abs(a));
-  b = Math.round(Math.abs(b));
-  while (b) {
-    const t = a % b;
-    a = b;
-    b = t;
-  }
-  return a;
-}
-
-export function idealBatchMultiplier(node: CalcNode): number {
-  let acc = 1;
-  const walk = (n: CalcNode): void => {
-    if (!Number.isFinite(acc)) return;
-    if (n.recipe && n.need > 0 && !n.cycle && n.batches > 0) {
-      const divisor = recipeDivisor(n.recipe, n.materialId, n.kind);
-      const mod =
-        (divisor * SCALE) / gcd(divisor * SCALE, n.need * SCALE);
-      acc = (acc * mod) / gcd(acc, mod);
-      if (!Number.isFinite(acc) || acc > CAP) {
-        acc = Infinity;
-        return;
-      }
-    }
-    for (const child of n.children) walk(child);
-  };
-  walk(node);
-  return acc;
-}

package/src/lib/calc/tree/pick.ts

@@ -1,68 +0,0 @@
-import type { CalcRecipeSummary } from '@terrafirmagreg-team/recipe/types/calc';
-import type { BuildContext } from './context';
-
-export type AutoPickResult = {
-
-  pick?: string;
-
-  wantRecipes: string[];
-
-  wantOut: string[];
-};
-
-const TIER_WEIGHT = 2;
-
-export function calcAutoPick(
-  rows: CalcRecipeSummary[],
-  materialId: string,
-  ancestors: ReadonlySet<string>,
-  ctx: Pick<
-    BuildContext,
-    'recipeMap' | 'getRecipesForItem' | 'recipesResolved' | 'deadIds'
-  >,
-): AutoPickResult {
-  const alive = rows.filter((row) => !ctx.deadIds?.has(row.recipeId));
-
-  const crafted = alive.filter((row) => !/(^|_)loot(_|$)/.test(row.category));
-  const pool = crafted.length ? crafted : alive;
-  const isCycle = (input: string) =>
-    input === materialId ||
-    ancestors.has(`item:${input}`) ||
-    ancestors.has(`fluid:${input}`);
-  const wantRecipes: string[] = [];
-  const wantOut = new Set<string>();
-  for (const row of pool) {
-    if (!ctx.recipeMap.has(row.recipeId)) wantRecipes.push(row.recipeId);
-    for (const input of row.row.in) {
-
-      if (input.startsWith('#') || isCycle(input)) continue;
-      if (!(ctx.recipesResolved?.(input) ?? true)) wantOut.add(input);
-    }
-  }
-  if (wantRecipes.length || wantOut.size) {
-    return { wantRecipes, wantOut: [...wantOut] };
-  }
-  const inputGuess = (input: string): number => {
-    if (isCycle(input)) return Infinity;
-    if (input.startsWith('#')) return 1;
-    return ctx.getRecipesForItem(input, 'item').length ? 1 : 0;
-  };
-  let best: CalcRecipeSummary | undefined;
-  let bestCost = Infinity;
-  for (const row of pool) {
-    let cost = 1 + TIER_WEIGHT * (ctx.recipeMap.get(row.recipeId)?.tier ?? 0);
-    for (const input of new Set(row.row.in)) {
-      cost += inputGuess(input);
-      if (cost === Infinity) break;
-    }
-    if (cost < bestCost) {
-      best = row;
-      bestCost = cost;
-    }
-  }
-  return {
-    pick: best?.recipeId ?? pool[0]?.recipeId ?? rows[0]?.recipeId,
-    wantRecipes,
-    wantOut: [],
-  };
-}