@terrafirmagreg-team/recipe 0.1.0 → 1.2.0

package/src/lib/calc/scheme.ts

@@ -0,0 +1,226 @@
+import type {
+  CalcCard,
+  CalcKind,
+  CalcMaterial,
+  CalcNode,
+  CalcNodeInput,
+  CalcOutput,
+  CalcRecipe,
+  CalcRecipeSummary,
+  CalcWire,
+  TagResolution,
+} from '@terrafirmagreg-team/recipe/types/calc';
+import { mergeAmounts } from './tree/materials';
+
+export type SchemeContext = {
+  recipeMap: Map<string, CalcRecipe>;
+  getRecipesForItem: (materialId: string, kind: CalcKind) => CalcRecipeSummary[];
+  tagMembers: (tagId: string) => TagResolution | undefined;
+  tagSelections: Record<string, string>;
+  recipesResolved: (id: string) => boolean;
+  deadIds: ReadonlySet<string>;
+};
+
+function outputAmount(
+  recipe: CalcRecipe,
+  materialId: string,
+  kind: CalcKind,
+): number {
+  return recipe.outputs
+    .filter((out) => out.id === materialId && out.kind === kind)
+    .reduce((sum, out) => sum + out.amount * (out.chance ?? 1), 0);
+}
+
+function inputMember(
+  input: CalcRecipe['inputs'][number],
+  ctx: SchemeContext,
+): { id?: string; kind: CalcKind } {
+  if (!input.tagId) return { id: input.id, kind: input.kind };
+  const picked = ctx.tagSelections[input.tagId];
+  const resolution = ctx.tagMembers(input.tagId);
+  const members = resolution?.members ?? [];
+  const memberId =
+    picked && members.includes(picked) ? picked : members[0];
+  return { id: memberId, kind: resolution?.kind ?? input.kind };
+}
+
+export function buildScheme({
+  cards,
+  wires,
+  ctx,
+}: {
+  cards: readonly CalcCard[];
+  wires: readonly CalcWire[];
+  ctx: SchemeContext;
+}): { nodes: CalcNode[]; flows: (number | undefined)[] } {
+  const byId = new Map<string, CalcNode>();
+  const nodes = cards.map((card) => {
+    const availableRecipes = ctx.getRecipesForItem(card.materialId, card.kind);
+    const recipe = card.recipeId
+      ? (ctx.recipeMap.get(card.recipeId) ?? null)
+      : null;
+    const resolved = card.recipeId ? !!recipe : true;
+    const out = recipe
+      ? outputAmount(recipe, card.materialId, card.kind)
+      : 1;
+    const produced = card.crafts * out;
+    const outputs: CalcOutput[] = [];
+    const addOutput = (entry: CalcOutput) => {
+      if (!(entry.amount > 0)) return;
+      const same = outputs.find(
+        (o) => o.id === entry.id && o.kind === entry.kind,
+      );
+      if (same) {
+        same.amount += entry.amount;
+        same.remaining += entry.amount;
+      } else {
+        outputs.push(entry);
+      }
+    };
+    addOutput({
+      id: card.materialId,
+      kind: card.kind,
+      amount: produced,
+      allocated: 0,
+      remaining: produced,
+    });
+    for (const o of recipe?.outputs ?? []) {
+      if (o.id === card.materialId && o.kind === card.kind) continue;
+      addOutput({
+        id: o.id,
+        kind: o.kind,
+        amount: o.amount * card.crafts,
+        chance: o.chance,
+        allocated: 0,
+        remaining: o.amount * card.crafts,
+      });
+    }
+    const node: CalcNode = {
+      id: card.id,
+      materialId: card.materialId,
+      kind: card.kind,
+      crafts: card.crafts,
+      produced,
+      allocated: 0,
+      remaining: produced,
+      outputs,
+      recipe,
+      inputs: (recipe?.inputs ?? []).map((entry) => {
+        const member = inputMember(entry, ctx);
+        return {
+          id: member.id,
+          kind: member.kind,
+          amount: entry.catalyst
+            ? entry.amount
+            : entry.amount * card.crafts,
+          catalyst: entry.catalyst,
+          tagId: entry.tagId,
+          wired: false,
+          covered: 0,
+        } satisfies CalcNodeInput;
+      }),
+      availableRecipes,
+      cycle: false,
+      products: false,
+      loading:
+        !ctx.recipesResolved(card.materialId) ||
+        (card.recipeId ? !resolved && !ctx.deadIds.has(card.recipeId) : false),
+    };
+    byId.set(card.id, node);
+    return node;
+  });
+
+  const flows: (number | undefined)[] = new Array(wires.length);
+  const deg = new Map<string, number>();
+  const adj = new Map<string, string[]>();
+  wires.forEach((wire, wireIndex) => {
+    const src = byId.get(wire.from);
+    const dst = byId.get(wire.to);
+    if (!src || !dst || src === dst) return;
+    const input = dst.inputs[wire.input];
+    const atIndex = src.outputs[wire.out ?? 0];
+    const outIndex =
+      input && atIndex && atIndex.id === input.id && atIndex.kind === input.kind
+        ? (wire.out ?? 0)
+        : input
+          ? src.outputs.findIndex(
+              (o) => o.id === input.id && o.kind === input.kind,
+            )
+          : -1;
+    const srcOut = outIndex >= 0 ? src.outputs[outIndex] : undefined;
+    if (!input || !srcOut) return;
+    if (!input.id) return;
+    input.wired = true;
+    const covered = Math.min(
+      Math.max(srcOut.remaining, 0),
+      input.amount - input.covered,
+      wire.amount ?? Infinity,
+    );
+    input.covered += covered;
+    srcOut.allocated += covered;
+    srcOut.remaining -= covered;
+    if (outIndex === 0) {
+      src.allocated += covered;
+      src.remaining -= covered;
+    }
+    flows[wireIndex] = covered;
+    adj.set(wire.from, [...(adj.get(wire.from) ?? []), wire.to]);
+    deg.set(wire.to, (deg.get(wire.to) ?? 0) + 1);
+  });
+
+  const cyclic = (start: string): boolean => {
+    const seen = new Set<string>();
+    const walk = (id: string): boolean => {
+      for (const next of adj.get(id) ?? []) {
+        if (next === start) return true;
+        if (seen.has(next)) continue;
+        seen.add(next);
+        if (walk(next)) return true;
+      }
+      return false;
+    };
+    return walk(start);
+  };
+  for (const node of nodes) node.cycle = cyclic(node.id);
+
+  for (const node of nodes) {
+    node.products = !(adj.get(node.id)?.length);
+  }
+  return { nodes, flows };
+}
+
+export function schemeSummary(nodes: readonly CalcNode[]) {
+  const raw: CalcMaterial[] = [];
+  const catalysts: CalcMaterial[] = [];
+  const surplus: CalcMaterial[] = [];
+  const products: CalcMaterial[] = [];
+  for (const node of nodes) {
+    for (const input of node.inputs) {
+      if (!input.id) continue;
+      if (input.catalyst) {
+        catalysts.push({ id: input.id, kind: input.kind, amount: input.amount });
+        continue;
+      }
+      const deficit = input.amount - input.covered;
+      if (deficit > 0) raw.push({ id: input.id, kind: input.kind, amount: deficit });
+    }
+    if (!node.recipe && node.produced > 0 && !node.products) {
+      raw.push({ id: node.materialId, kind: node.kind, amount: node.produced });
+    }
+    if (node.products && node.produced > 0) {
+      products.push({ id: node.materialId, kind: node.kind, amount: node.produced });
+    }
+    for (const out of node.outputs.slice(node.products ? 1 : 0)) {
+      if (out.remaining > 0) {
+        surplus.push({ id: out.id, kind: out.kind, amount: out.remaining });
+      }
+    }
+  }
+  return {
+    raw: mergeAmounts(raw),
+    catalysts,
+    remainders: mergeAmounts(surplus),
+    products: mergeAmounts(products),
+  };
+}
+

package/src/lib/calc/storage/entry.ts

@@ -23,37 +23,44 @@ export function newCalcEntry(state: CalculatorState, name?: string): CalcTreeEnt
   };
 }
 
-const isTargetRow = (t: unknown): boolean =>
-  !!t &&
-  typeof t === 'object' &&
-  typeof (t as { id?: unknown }).id === 'string';
+const isCardRow = (row: unknown): boolean =>
+  !!row &&
+  typeof row === 'object' &&
+  typeof (row as { id?: unknown }).id === 'string' &&
+  typeof (row as { materialId?: unknown }).materialId === 'string' &&
+  ((row as { kind?: unknown }).kind === 'item' ||
+    (row as { kind?: unknown }).kind === 'fluid');
+
+const isWireRow = (row: unknown): boolean =>
+  !!row &&
+  typeof row === 'object' &&
+  typeof (row as { from?: unknown }).from === 'string' &&
+  typeof (row as { to?: unknown }).to === 'string' &&
+  typeof (row as { input?: unknown }).input === 'number';
 
 export function isCalcState(value: unknown): value is CalculatorState {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
   const row = value as Record<string, unknown>;
-  const targetOk = Array.isArray(row.targets)
-    ?
-      row.targets.every(isTargetRow)
-    : row.target === null || row.target === undefined || isTargetRow(row.target);
   return (
-    targetOk &&
-    !!row.selections &&
-    typeof row.selections === 'object' &&
+    Array.isArray(row.cards) &&
+    row.cards.every(isCardRow) &&
+    Array.isArray(row.wires) &&
+    row.wires.every(isWireRow) &&
     !!row.tagSelections &&
     typeof row.tagSelections === 'object'
   );
 }
 
 export function migrateCalcState(state: CalculatorState): CalculatorState {
-  const legacy = (state as CalculatorState & { targets?: unknown }).targets;
-  if (state.target !== undefined || !Array.isArray(legacy)) {
-    return { inventory: [], ...state, target: state.target ?? null };
-  }
-  const [first] = legacy as { id: string; kind: 'item' | 'fluid'; amount: number }[];
-  const { targets: _drop, ...rest } = state as CalculatorState & {
-    targets?: unknown;
+  const cards = Array.isArray(state.cards) ? state.cards.filter(isCardRow) : [];
+  const ids = new Set(cards.map((card) => card.id));
+  return {
+    cards,
+    wires: (Array.isArray(state.wires) ? state.wires.filter(isWireRow) : []).filter(
+      (wire) => ids.has(wire.from) && ids.has(wire.to),
+    ),
+    tagSelections: state.tagSelections,
   };
-  return { inventory: [], ...rest, target: first ?? null };
 }
 
 function isEntry(value: unknown): value is CalcTreeEntry {
@@ -87,3 +94,4 @@ export function capHistory(entries: CalcTreeEntry[]): CalcTreeEntry[] {
   }
   return out;
 }
+

package/src/lib/calc/storage/index.ts

@@ -7,6 +7,7 @@ export { calcStorageKey } from './keys';
 export {
   readCalcActive,
   readCalcHistory,
+  resolveCalcActive,
   readCalcStorage,
   readCalcTabs,
   removeCalcHistory,
@@ -16,3 +17,4 @@ export {
   writeCalcStorage,
   writeCalcTabs,
 } from './store';
+

package/src/lib/calc/storage/keys.ts

@@ -1,10 +1,9 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 export const CALC_STATE_EVENT = 'tfg:calc-state';
 const TAB_KEY = 'tfg:calc-tab';
 const ACTIVE_PREFIX = 'calc:active:';
 const HIST_PREFIX = 'calc:hist:';
 
-export const LEGACY_PREFIX = 'calc:';
-
 let tabId: string | null = null;
 
 function calcTabId(): string {
@@ -21,9 +20,9 @@ function calcTabId(): string {
   return tabId;
 }
 
-export function calcStorageKey(section: string, dataset: string): string {
+export function calcStorageKey(section: string, dataset: DatasetRef): string {
   void calcTabId();
-  return `calc:tabs:${section}:${dataset}`;
+  return `calc:tabs:${section}:${dataset.id}/${dataset.version ?? ''}`;
 }
 
 export function activeKey(key: string): string {
@@ -34,9 +33,6 @@ export function historyKey(key: string): string {
   return `${HIST_PREFIX}${key}`;
 }
 
-export function datasetTail(key: string): string {
-  return key.slice('calc:tabs:'.length);
-}
-
 export const emitCalcStorage = () =>
   window.dispatchEvent(new Event(CALC_STATE_EVENT));
+

package/src/lib/calc/storage/store.ts

@@ -3,7 +3,6 @@ import {
   capHistory,
   EMPTY_ENTRIES,
   isCalcHistory,
-  isCalcState,
   isCalcTabs,
   migrateCalcState,
   newCalcEntry,
@@ -12,10 +11,8 @@ import {
 import {
   activeKey,
   CALC_STATE_EVENT,
-  datasetTail,
   emitCalcStorage,
   historyKey,
-  LEGACY_PREFIX,
 } from './keys';
 
 function readJSON<T>(raw: string | null, guard: (v: unknown) => v is T): T | null {
@@ -50,37 +47,8 @@ const migrateEntries = (entries: CalcTreeEntry[]): void => {
   }
 };
 
-const migrated = new Set<string>();
-
-function migrateLegacy(hKey: string, tail: string): void {
-  if (migrated.has(hKey) || typeof window === 'undefined') return;
-  migrated.add(hKey);
-  const legacyKey = `${LEGACY_PREFIX}${tail}`;
-  try {
-    const legacy = readJSON(
-      window.localStorage.getItem(legacyKey),
-      isCalcState,
-    );
-    const migratedState = legacy && migrateCalcState(legacy);
-    if (migratedState?.target) {
-      const entry = newCalcEntry(migratedState);
-      const entries =
-        readJSON(window.localStorage.getItem(hKey), isCalcHistory) ?? [];
-      window.localStorage.setItem(
-        hKey,
-        JSON.stringify(capHistory([entry, ...entries])),
-      );
-    }
-    for (let i = window.localStorage.length - 1; i >= 0; i -= 1) {
-      const name = window.localStorage.key(i);
-      if (name?.startsWith(legacyKey)) window.localStorage.removeItem(name);
-    }
-  } catch {}
-}
-
 export function readCalcTabs(key: string): CalcTreeEntry[] {
   if (typeof window === 'undefined') return [];
-  migrateLegacy(historyKey(key), datasetTail(key));
   return (
     snap(key, window.localStorage.getItem(key), isCalcTabs, migrateEntries) ??
     EMPTY_ENTRIES
@@ -99,7 +67,6 @@ export function readCalcActive(key: string): string | null {
 export function readCalcHistory(key: string): CalcTreeEntry[] {
   if (typeof window === 'undefined') return [];
   const hKey = historyKey(key);
-  migrateLegacy(hKey, datasetTail(key));
   return (
     snap(hKey, window.localStorage.getItem(hKey), isCalcHistory, migrateEntries) ??
     EMPTY_ENTRIES
@@ -118,7 +85,7 @@ function writeHistoryRaw(key: string, entries: CalcTreeEntry[]): void {
 }
 
 function syncHistory(key: string, tabs: CalcTreeEntry[]): void {
-  const live = tabs.filter((tab) => tab.state.target);
+  const live = tabs.filter((tab) => tab.state.cards.length);
   if (!live.length) return;
   const prev = readCalcHistory(key);
   const ids = new Set(live.map((tab) => tab.id));
@@ -189,9 +156,16 @@ export function removeCalcHistory(key: string, id: string): void {
   emitCalcStorage();
 }
 
+export function resolveCalcActive(
+  tabs: readonly CalcTreeEntry[],
+  raw: string | null,
+): string | null {
+  return (tabs.find((tab) => tab.id === raw) ?? tabs[0])?.id ?? null;
+}
+
 export function readCalcStorage(key: string): CalculatorState | null {
   const tabs = readCalcTabs(key);
-  const active = readCalcActive(key);
+  const active = resolveCalcActive(tabs, readCalcActive(key));
   return tabs.find((tab) => tab.id === active)?.state ?? null;
 }
 
@@ -200,7 +174,7 @@ export function writeCalcStorage(
   state: CalculatorState,
 ): void {
   const tabs = readCalcTabs(key);
-  const active = readCalcActive(key);
+  const active = resolveCalcActive(tabs, readCalcActive(key));
   const index = tabs.findIndex((tab) => tab.id === active);
   if (index >= 0) {
     const next = tabs.slice();
@@ -221,3 +195,4 @@ export function subscribeCalcStorage(listener: () => void): () => void {
     window.removeEventListener('storage', listener);
   };
 }
+

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

@@ -1,18 +1,4 @@
-export {
-  AUTO_MAX_DEPTH,
-  AUTO_NODE_BUDGET,
-  type BuildContext,
-  type CalcGoal,
-  type RemainderPool,
-} from './context';
 export { mergeAmounts } from './materials';
 export { recipeDivisor, toCalcRecipe } from './recipe';
-export { calcAutoPick, type AutoPickResult } from './pick';
-export { buildTree } from './build';
-export { buildGoal, flattenTree } from './goal';
-export { idealBatchMultiplier } from './ideal';
-export {
-  decodeCalcState,
-  encodeCalcShare,
-  encodeCalcState,
-} from './share';
+export { decodeCalcState, encodeCalcState } from './share';
+

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

@@ -26,3 +26,4 @@ export function deduplicateMaterials(list: CalcMaterial[]): CalcMaterial[] {
   }
   return result;
 }
+

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

@@ -101,3 +101,4 @@ export function recipeDivisor(
     .reduce((sum, out) => sum + out.amount * (out.chance ?? 1), 0);
   return amount > 0 ? amount : 1;
 }
+