@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/alloy/mix.ts

@@ -0,0 +1,210 @@
+import type { AlloyComponent, AlloyMixRow } from '@terrafirmagreg-team/recipe/types/alloy';
+
+export const INGOT_MB = 144;
+
+const MAX_INGOT_BATCH = 128;
+
+function gcd(a: number, b: number): number {
+  return b ? gcd(b, a % b) : a;
+}
+
+export function ingotRatioMix(
+  components: readonly AlloyComponent[],
+): { counts: number[]; total: number } | null {
+  const scaled = components.map(({ slot }) => Math.round(slot.amount * 100));
+  if (!scaled.length || scaled.some((value) => value <= 0)) return null;
+  const divisor = scaled.reduce(gcd);
+  const counts = scaled.map((value) => value / divisor);
+  const total = counts.reduce((sum, value) => sum + value, 0);
+  return total <= MAX_INGOT_BATCH ? { counts, total } : null;
+}
+
+function componentsOk(
+  components: readonly AlloyComponent[],
+): components is readonly (AlloyComponent & { slot: { amount: number } })[] {
+  return (
+    components.length > 0 &&
+    components.every(
+      ({ slot }) => Number.isFinite(slot.amount) && slot.amount > 0,
+    )
+  );
+}
+
+function distributeUnits(shares: readonly number[], total: number): number[] {
+  const units = Math.max(1, Math.round(total));
+  const floors = shares.map((share) => Math.floor(share));
+  const leftover = units - floors.reduce((sum, value) => sum + value, 0);
+  const order = shares
+    .map((share, i) => [share - floors[i], i] as const)
+    .sort((a, b) => b[0] - a[0]);
+  for (let i = 0; i < leftover && order.length; i++) {
+    floors[order[i % order.length][1]]++;
+  }
+  return floors;
+}
+
+export function suggestAmounts(
+  components: readonly AlloyComponent[],
+  total: number,
+): number[] | null {
+  if (!componentsOk(components) || !Number.isFinite(total) || total <= 0) {
+    return null;
+  }
+  const sum = components.reduce((value, { slot }) => value + slot.amount, 0);
+  if (!Number.isFinite(sum) || sum <= 0) return null;
+  const units = Math.round(total);
+  if (units <= 0) return null;
+  return distributeUnits(
+    components.map(({ slot }) => (units * slot.amount) / sum),
+    units,
+  );
+}
+
+export function scaleAmounts(
+  amounts: readonly number[],
+  total: number,
+): number[] | null {
+  const sum = amounts.reduce((value, amount) => value + Math.max(0, amount), 0);
+  if (!Number.isFinite(total) || total <= 0 || sum <= 0) return null;
+  const units = Math.round(total);
+  if (units <= 0) return null;
+  return distributeUnits(
+    amounts.map((amount) => (Math.max(0, amount) / sum) * units),
+    units,
+  );
+}
+
+export function checkMix(
+  components: readonly AlloyComponent[],
+  amounts: readonly number[],
+): { total: number; output: number; rows: AlloyMixRow[]; valid: boolean } {
+  const total = amounts.reduce((sum, value) => sum + Math.max(0, value), 0);
+  const rows = components.map((component, i) => {
+    const amount = Math.max(0, amounts[i] ?? 0);
+    const percent = total > 0 ? (amount / total) * 100 : 0;
+    const { range } = component;
+    const valid =
+      !range ||
+      (percent >= range.min - 1e-8 && percent <= range.max + 1e-8);
+    return { ...component, amount, percent, valid };
+  });
+  return {
+    total,
+    output: total,
+    rows,
+    valid: total > 0 && rows.every((row) => row.valid),
+  };
+}
+
+export function snapToIngots(
+  components: readonly AlloyComponent[],
+  amounts: readonly number[],
+): number[] | null {
+  const count = components.length;
+  if (!count) return null;
+  const lows = components.map((_, i) =>
+    Math.max(0, Math.round((amounts[i] ?? 0) / INGOT_MB) - 1),
+  );
+  let best: number[] | null = null;
+  let bestDiff = Infinity;
+  for (let code = 0, limit = 3 ** count; code < limit; code++) {
+    let rest = code;
+    const snapped = new Array<number>(count);
+    for (let i = 0; i < count; i++) {
+      snapped[i] = (lows[i] + (rest % 3)) * INGOT_MB;
+      rest = Math.floor(rest / 3);
+    }
+    if (!checkMix(components, snapped).valid) continue;
+    const diff = snapped.reduce(
+      (sum, value, i) => sum + Math.abs(value - (amounts[i] ?? 0)),
+      0,
+    );
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      best = snapped;
+    }
+  }
+  return best;
+}
+
+export function minShareMix(
+  components: readonly AlloyComponent[],
+  index: number,
+  total: number,
+): number[] | null {
+  const range = components[index]?.range;
+  if (
+    !range ||
+    !componentsOk(components) ||
+    !Number.isFinite(total) ||
+    total <= 0
+  ) {
+    return null;
+  }
+  const units = Math.round(total);
+
+  const pinned = Math.max(1, Math.ceil((units * range.min) / 100));
+  const rest = units - pinned;
+  if (rest <= 0) return null;
+  const restSum = components.reduce(
+    (sum, { slot }, i) => sum + (i === index ? 0 : slot.amount),
+    0,
+  );
+  const shares = components.map(({ slot }, i) =>
+    i === index ? 0 : (rest * slot.amount) / restSum,
+  );
+  const dist = distributeUnits(shares, rest);
+  dist[index] = pinned;
+  return dist;
+}
+
+export function minimalAdditions(
+  components: readonly AlloyComponent[],
+  amounts: readonly number[],
+): number[] | null {
+  if (!componentsOk(components)) return null;
+  const next = components.map((_, i) => Math.max(0, amounts[i] ?? 0));
+  for (let pass = 0; pass < 256; pass++) {
+    const { rows, valid } = checkMix(components, next);
+    if (valid) return next.map((value, i) => value - Math.max(0, amounts[i] ?? 0));
+    const over = rows.filter((row) => row.range && row.percent > row.range.max);
+    const under = rows.filter((row) => row.range && row.percent < row.range.min);
+    const total = rows.reduce((sum, row) => sum + row.amount, 0);
+
+    if (over.length && !under.length) {
+
+      const extra = over[0];
+      const neededTotal = (next[rows.indexOf(extra)] * 100) / extra.range!.max;
+      const room = rows.filter(
+        (row) => !over.includes(row) && (!row.range || row.percent < row.range.max),
+      );
+      if (!room.length) return null;
+      const target = room.sort(
+        (a, b) =>
+          (b.range?.max ?? Infinity) - b.percent -
+          ((a.range?.max ?? Infinity) - a.percent),
+      )[0];
+      const index = rows.indexOf(target);
+      if (!target.range) {
+        next[index] += neededTotal - total;
+        continue;
+      }
+      const addNeed = neededTotal - total;
+      const addMax =
+        (target.range.max * total - 100 * next[index]) / (100 - target.range.max);
+      next[index] += Math.max(Math.ceil(Math.min(addNeed, addMax)), 1);
+      continue;
+    }
+
+    const target = under.sort(
+      (a, b) => a.percent - a.range!.min - (b.percent - b.range!.min),
+    )[0];
+    if (!target) return null;
+    const index = rows.indexOf(target);
+    const add =
+      (target.range!.min * total - 100 * next[index]) / (100 - target.range!.min);
+    next[index] += Math.max(Math.ceil(add), 1);
+  }
+  return null;
+}
+

package/src/lib/alloy/parse.ts

@@ -0,0 +1,37 @@
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type { AlloyComponent, AlloyRecipe } from '@terrafirmagreg-team/recipe/types/alloy';
+import { cleanForgeText } from '@terrafirmagreg-team/recipe/lib/forge/actions';
+
+export function parseAlloyPercent(
+  text: string,
+): { min: number; max: number } | undefined {
+  const match = /^(\d+(?:\.\d+)?)\s*[-–]\s*(\d+(?:\.\d+)?)\s*%$/.exec(
+    cleanForgeText(text),
+  );
+  if (!match) return undefined;
+  const min = Number(match[1]);
+  const max = Number(match[2]);
+  return min >= 0 && min <= max && max <= 100 ? { min, max } : undefined;
+}
+
+export function toAlloyRecipe(recipe: Recipe): AlloyRecipe {
+  const inputs = Object.entries(recipe.slots)
+    .filter(([, slot]) => slot.type === 'input')
+    .sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
+    .map(([, slot]) => slot);
+  const ranges = recipe.widgets
+    .filter((widget) => widget.type === 'text')
+    .map((widget) => ({
+      x: widget.x,
+      y: widget.y,
+      range: parseAlloyPercent(widget.text ?? ''),
+    }))
+    .filter((widget) => widget.range !== undefined)
+    .sort((a, b) => a.y - b.y || a.x - b.x);
+  const components: AlloyComponent[] = inputs.map((slot, i) => ({
+    slot,
+    ...(ranges.length === inputs.length ? { range: ranges[i].range } : {}),
+  }));
+  return { recipe, components };
+}
+

package/src/lib/calc/defaults.ts

@@ -0,0 +1,47 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+const KEY_PREFIX = 'calc:recipe-defaults:';
+
+export function readRecipeDefaults(dataset: DatasetRef): Record<string, string> {
+  if (typeof window === 'undefined') return {};
+  try {
+    const raw = window.localStorage.getItem(`${KEY_PREFIX}${dataset.id}/${dataset.version ?? ''}`);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+      return {};
+    return Object.fromEntries(
+      Object.entries(parsed as Record<string, unknown>).filter(
+        ([key, value]) =>
+          typeof key === 'string' && typeof value === 'string',
+      ) as [string, string][],
+    );
+  } catch {
+    return {};
+  }
+}
+
+const EVENT = 'tfg:recipe-defaults';
+
+export function subscribeRecipeDefaults(listener: () => void): () => void {
+  if (typeof window === 'undefined') return () => {};
+  window.addEventListener(EVENT, listener);
+  return () => window.removeEventListener(EVENT, listener);
+}
+
+export function writeRecipeDefault(
+  dataset: DatasetRef,
+  materialId: string,
+  recipeId: string | null,
+): Record<string, string> {
+  const next = readRecipeDefaults(dataset);
+  if (recipeId === null) delete next[materialId];
+  else next[materialId] = recipeId;
+  try {
+    window.localStorage.setItem(`${KEY_PREFIX}${dataset.id}/${dataset.version ?? ''}`, JSON.stringify(next));
+  } catch {
+
+  }
+  window.dispatchEvent(new Event(EVENT));
+  return next;
+}
+

package/src/lib/calc/flow.ts

@@ -0,0 +1,315 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { Edge, Node } from '@terrafirmagreg-team/ui/lib/canvas/xyflow';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import { PORT_IN } from '@terrafirmagreg-team/recipe/lib/calc/ports';
+import type {
+  CalcKind,
+  CalcNode,
+  CalcRecipeSummary,
+  CalcWire,
+} from '@terrafirmagreg-team/recipe/types/calc';
+import type { FlowPoint } from '@terrafirmagreg-team/ui/types/canvas';
+
+export const CALC_NODE_W = 232;
+export const CALC_NODE_H = 76;
+
+export const CALC_LOD_FAR = 0.45;
+
+export const CALC_LOD_DOT = 0.15;
+const CALC_MINI_W = 96;
+const CALC_MINI_TAG_H = 84;
+
+export type CalcViewMode = 'mini' | 'normal' | 'detailed';
+export type CalcFarMode = 'full' | 'preview' | 'hidden';
+
+export const GRID_GAPS = { x: 14, y: 24, goal: 48 };
+
+export type CalcTier = 'dot' | 'far' | 'near';
+
+export type CalcFlowData = {
+  node: CalcNode;
+  dataset: DatasetRef;
+  mode: CalcViewMode;
+  recipeBody: (recipeId: string) => Recipe | undefined;
+  onSelectRecipe: (cardId: string, recipeId: string | null) => void;
+  onSelectTagMember: (tagId: string, memberId: string) => void;
+  onRequestPicker: (node: CalcNode) => void;
+  onRequestMemberPicker: (node: CalcNode) => void;
+  onRequestSupply: (node: CalcNode, input: number) => void;
+  onSupplyInput: (
+    cardId: string,
+    inputIndex: number,
+    recipeId: string | null,
+    outputAmount?: number,
+  ) => string | null;
+  getRecipesForItem: (
+    materialId: string,
+    kind: CalcKind,
+  ) => CalcRecipeSummary[];
+  ensureMaterial: (materialId: string) => void;
+  onAddCard: (
+    materialId: string,
+    kind: CalcKind,
+    pos?: { x: number; y: number },
+  ) => string;
+  onOpenItem: (materialId: string, kind: CalcKind) => void;
+  onRemoveCard: (cardId: string) => void;
+  onMoveCard: (cardId: string, pos: { x: number; y: number }) => void;
+  onCrafts: (cardId: string, crafts: number) => void;
+  onWire: (from: string, to: string, input: number, out?: number) => void;
+  onUnwire: (
+    from: string,
+    to: string,
+    input: number,
+    out?: number,
+  ) => void;
+  onRewire: (
+    from: string,
+    to: string,
+    input: number,
+    next: { from: string; to: string; input: number; out?: number },
+  ) => void;
+  onWireAmount: (
+    from: string,
+    to: string,
+    input: number,
+    amount: number | null,
+  ) => void;
+  recipeDefaults: Record<string, string>;
+  onSetRecipeDefault: (materialId: string, recipeId: string | null) => void;
+};
+
+export type CalcFlowNode = Node<CalcFlowData, 'calcMaterial'>;
+export type AnyCalcFlowNode = CalcFlowNode;
+
+export function nodeSize(
+  calc: CalcNode,
+  ctx: { mode: CalcViewMode; recipeBody: (id: string) => Recipe | undefined },
+): { w: number; h: number } {
+  const margin =
+    (calc.inputs.length ? PORT_IN : 0) + (calc.outputs.length ? PORT_IN : 0);
+  if (ctx.mode === 'mini') {
+    return { w: CALC_MINI_W + margin, h: CALC_MINI_TAG_H };
+  }
+  const body = calc.recipe ? ctx.recipeBody(calc.recipe.recipeId) : undefined;
+  if (ctx.mode === 'detailed' && body?.w && body.h) {
+    return {
+      w: Math.max(CALC_NODE_W, body.w + 16) + margin,
+      h: CALC_NODE_H + body.h + 6,
+    };
+  }
+  return { w: CALC_NODE_W + margin, h: CALC_NODE_H };
+}
+
+export function cardsToFlow(
+  nodes: CalcNode[],
+  wires: readonly CalcWire[],
+  data: Omit<CalcFlowData, 'node'>,
+  flows?: readonly (number | undefined)[],
+): { nodes: AnyCalcFlowNode[]; edges: Edge[] } {
+  const flowNodes: AnyCalcFlowNode[] = nodes.map((node) => {
+    const { w, h } = nodeSize(node, {
+      mode: data.mode,
+      recipeBody: data.recipeBody,
+    });
+    return {
+      id: node.id,
+      type: 'calcMaterial',
+      position: { x: 0, y: 0 },
+      width: w,
+      height: h,
+      data: { ...data, node },
+    };
+  });
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const edges: Edge[] = wires.flatMap((wire, index) => {
+    const src = byId.get(wire.from);
+    const dst = byId.get(wire.to);
+    const input = dst?.inputs[wire.input];
+    if (!src || !dst || !input || !input.wired) return [];
+    const atIndex = src.outputs[wire.out ?? 0];
+    const outIndex =
+      atIndex && atIndex.id === input.id && atIndex.kind === input.kind
+        ? (wire.out ?? 0)
+        : src.outputs.findIndex(
+            (o) => o.id === input.id && o.kind === input.kind,
+          );
+    if (outIndex < 0) return [];
+    const mat = src.outputs[outIndex];
+    return [
+      {
+        id: `wire:${wire.from}->${wire.to}:${wire.input}:${index}`,
+        source: wire.from,
+        sourceHandle: outIndex > 0 ? `out-${outIndex}` : 'out',
+        target: wire.to,
+        targetHandle: `in-${wire.input}`,
+        type: 'calcEdge',
+        className: 'calc-edge--wire',
+        deletable: true,
+        data: {
+          wire,
+          flow: flows?.[index],
+          matId: mat?.id ?? input.id,
+          matKind: mat?.kind ?? input.kind,
+          dataset: data.dataset,
+          onWireAmount: data.onWireAmount,
+          onUnwire: data.onUnwire,
+        },
+      },
+    ];
+  });
+  return { nodes: flowNodes, edges };
+}
+
+function sameCalcNode(a: CalcNode, b: CalcNode): boolean {
+  return (
+    a.id === b.id &&
+    a.materialId === b.materialId &&
+    a.kind === b.kind &&
+    a.crafts === b.crafts &&
+    a.produced === b.produced &&
+    a.allocated === b.allocated &&
+    a.remaining === b.remaining &&
+    a.outputs.length === b.outputs.length &&
+    a.outputs.every(
+      (out, index) =>
+        out.id === b.outputs[index]?.id &&
+        out.kind === b.outputs[index]?.kind &&
+        out.amount === b.outputs[index]?.amount &&
+        out.allocated === b.outputs[index]?.allocated &&
+        out.remaining === b.outputs[index]?.remaining,
+    ) &&
+    a.cycle === b.cycle &&
+    a.products === b.products &&
+    a.recipe?.recipeId === b.recipe?.recipeId &&
+    a.recipe?.category === b.recipe?.category &&
+    a.tagId === b.tagId &&
+    a.loading === b.loading &&
+    a.inputs.length === b.inputs.length &&
+    a.inputs.every(
+      (inp, index) =>
+        inp.id === b.inputs[index]?.id &&
+        inp.amount === b.inputs[index]?.amount &&
+        inp.covered === b.inputs[index]?.covered &&
+        inp.wired === b.inputs[index]?.wired &&
+        inp.catalyst === b.inputs[index]?.catalyst,
+    ) &&
+    (a.members?.join() ?? '') === (b.members?.join() ?? '') &&
+    a.availableRecipes.length === b.availableRecipes.length &&
+    a.availableRecipes.every(
+      (row, index) =>
+        row.recipeId === b.availableRecipes[index]?.recipeId &&
+        row.outputAmount === b.availableRecipes[index]?.outputAmount &&
+        row.category === b.availableRecipes[index]?.category,
+    )
+  );
+}
+
+function sameFlowData(a: CalcFlowData, b: CalcFlowData): boolean {
+  return (
+    (a.node === b.node || sameCalcNode(a.node, b.node)) &&
+    a.dataset === b.dataset &&
+    a.mode === b.mode &&
+    a.recipeBody === b.recipeBody &&
+    a.onSelectRecipe === b.onSelectRecipe &&
+    a.onSelectTagMember === b.onSelectTagMember &&
+    a.onRequestPicker === b.onRequestPicker &&
+    a.onRequestMemberPicker === b.onRequestMemberPicker &&
+    a.onRequestSupply === b.onRequestSupply &&
+    a.onSupplyInput === b.onSupplyInput &&
+    a.getRecipesForItem === b.getRecipesForItem &&
+    a.ensureMaterial === b.ensureMaterial &&
+    a.onAddCard === b.onAddCard &&
+    a.onOpenItem === b.onOpenItem &&
+    a.onRemoveCard === b.onRemoveCard &&
+    a.onMoveCard === b.onMoveCard &&
+    a.onCrafts === b.onCrafts &&
+    a.onWire === b.onWire &&
+    a.onUnwire === b.onUnwire &&
+    a.onRewire === b.onRewire &&
+    a.onWireAmount === b.onWireAmount &&
+    a.recipeDefaults === b.recipeDefaults &&
+    a.onSetRecipeDefault === b.onSetRecipeDefault
+  );
+}
+
+export function reconcileCalcNodes(
+  prev: AnyCalcFlowNode[],
+  next: AnyCalcFlowNode[],
+): AnyCalcFlowNode[] {
+  const withDelay = (
+    node: AnyCalcFlowNode,
+    order: number,
+  ): AnyCalcFlowNode => ({
+    ...node,
+    style: {
+      ...node.style,
+      '--calc-delay': `${Math.min(order * 14, 300)}ms`,
+    } as CalcFlowNode['style'],
+  });
+
+  if (!prev.length) return next.map((node, i) => withDelay(node, i + 1));
+  const byId = new Map(prev.map((node) => [node.id, node]));
+  let changed = next.length !== prev.length;
+  let enters = 0;
+  const out = next.map((node) => {
+    const kept = byId.get(node.id);
+    if (
+      kept &&
+      kept.position.x === node.position.x &&
+      kept.position.y === node.position.y &&
+      kept.width === node.width &&
+      kept.height === node.height &&
+      kept.className === node.className &&
+      sameFlowData(kept.data, node.data)
+    ) {
+      return kept;
+    }
+    changed = true;
+    if (!kept) {
+      enters += 1;
+      return withDelay(node, enters);
+    }
+    return node;
+  });
+  return changed ? out : prev;
+}
+
+export function reconcileCalcEdges(
+  prev: Edge[],
+  next: Edge[],
+): Edge[] {
+  if (!prev.length) return next;
+  const byId = new Map(prev.map((edge) => [edge.id, edge]));
+  let changed = next.length !== prev.length;
+  const out = next.map((edge) => {
+    const kept = byId.get(edge.id);
+
+    if (
+      kept &&
+      kept.source === edge.source &&
+      kept.target === edge.target &&
+      kept.sourceHandle === edge.sourceHandle &&
+      kept.targetHandle === edge.targetHandle &&
+      kept.className === edge.className &&
+      kept.data?.flow === edge.data?.flow &&
+      (kept.data?.wire as CalcWire | undefined)?.amount ===
+        (edge.data?.wire as CalcWire | undefined)?.amount &&
+      ((kept.data?.points as FlowPoint[] | undefined)?.length ?? 0) ===
+        ((edge.data?.points as FlowPoint[] | undefined)?.length ?? 0) &&
+      (kept.data?.points as FlowPoint[] | undefined)?.every(
+        (point, i) =>
+          point.x ===
+            (edge.data?.points as FlowPoint[] | undefined)?.[i]?.x &&
+          point.y ===
+            (edge.data?.points as FlowPoint[] | undefined)?.[i]?.y,
+      ) !== false
+    ) {
+      return kept;
+    }
+    changed = true;
+    return edge;
+  });
+  return changed ? out : prev;
+}
+

package/src/lib/calc/focus.ts

@@ -0,0 +1,15 @@
+type Listener = (materialId: string) => void;
+
+const listeners = new Set<Listener>();
+
+export function requestCalcFocus(materialId: string): void {
+  for (const listener of listeners) listener(materialId);
+}
+
+export function onCalcFocusRequest(listener: Listener): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+

package/src/lib/calc/meta.ts

@@ -0,0 +1,17 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { CalcKind } from '@terrafirmagreg-team/recipe/types/calc';
+
+export type IconItem = { id: string; kind: CalcKind };
+
+export type EntryMeta = {
+  dataset: DatasetRef;
+  lang: string;
+  langMap?: Record<string, string>;
+  iconItems?: IconItem[];
+};
+
+export const rowClass =
+  'flex w-full items-center gap-1.5 rounded-md px-2 py-1 text-sm transition-colors';
+export const rowIdle =
+  'text-muted-foreground hover:bg-accent hover:text-accent-foreground';
+