@terrafirmagreg-team/recipe 0.1.0 → 1.2.0

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

@@ -1,8 +1,8 @@
 import { deflateSync, inflateSync, strFromU8, strToU8 } from 'fflate';
 import type {
-  CalcMaterial,
+  CalcCard,
   CalculatorState,
-  CalculatorTarget,
+  CalcWire,
 } from '@terrafirmagreg-team/recipe/types/calc';
 
 function encodeUrlSafe(base64: string): string {
@@ -25,48 +25,6 @@ function u8ToBinary(u8: Uint8Array): string {
 }
 
 export function encodeCalcState(state: CalculatorState): string {
-  return encodeCalcShare({
-    state,
-    autoRoots: state.auto ?? [],
-    pins: {},
-    derivablePick: () => undefined,
-  });
-}
-
-type SharePayload = {
-  v: 1;
-
-  d: string[];
-
-  t?: [number, number, number] | [number, number, number][];
-
-  i?: [number, number, number][];
-
-  a: string[];
-
-  s: Record<string, number>;
-
-  g: Record<string, number>;
-
-  c: string[];
-};
-
-export function encodeCalcShare({
-  state,
-  derivablePick,
-  pins = {},
-  autoRoots,
-  livePaths,
-}: {
-  state: CalculatorState;
-
-  derivablePick: (path: string) => string | undefined;
-
-  pins?: Record<string, string>;
-  autoRoots: readonly string[];
-
-  livePaths?: ReadonlySet<string>;
-}): string {
   const dict = new Map<string, number>();
   const ref = (id: string): number => {
     const hit = dict.get(id);
@@ -75,124 +33,103 @@ export function encodeCalcShare({
     dict.set(id, idx);
     return idx;
   };
-  const target = state.target
-    ? ([
-        ref(state.target.id),
-        state.target.kind === 'fluid' ? 1 : 0,
-        state.target.amount,
-      ] satisfies [number, number, number])
-    : undefined;
-  const inventory = (state.inventory ?? []).map(
-    (row): [number, number, number] => [
-      ref(row.id),
-      row.kind === 'fluid' ? 1 : 0,
-      row.amount,
-    ],
-  );
-  const selections: Record<string, number> = {};
-  for (const [key, value] of Object.entries(pins)) {
-    if (value) selections[`#${ref(key)}`] = ref(value);
-  }
-  for (const [path, recipeId] of Object.entries(state.selections)) {
-    if (!recipeId) continue;
-    if (livePaths && /^g\d/.test(path) && !livePaths.has(path)) continue;
-    if (derivablePick(path) === recipeId) continue;
-    selections[path] = ref(recipeId);
-  }
+  const indexOf = new Map<string, number>();
+  const cards = state.cards.map((card, index) => {
+    indexOf.set(card.id, index);
+    const row = [
+      ref(card.materialId),
+      card.kind === 'fluid' ? 1 : 0,
+      card.recipeId ? ref(card.recipeId) : -1,
+      card.crafts,
+      Math.round(card.pos?.x ?? 0),
+      Math.round(card.pos?.y ?? 0),
+      card.pos ? 1 : 0,
+    ];
+    return row;
+  });
+  const wires = state.wires.flatMap((wire) => {
+    const from = indexOf.get(wire.from);
+    const to = indexOf.get(wire.to);
+    return from === undefined || to === undefined
+      ? []
+      : [[from, to, wire.input, wire.out ?? 0, wire.amount ?? 0]];
+  });
   const tagSelections: Record<string, number> = {};
   for (const [tagId, memberId] of Object.entries(state.tagSelections)) {
-    if (!memberId) continue;
-    tagSelections[String(ref(tagId))] = ref(memberId);
+    if (memberId) tagSelections[String(ref(tagId))] = ref(memberId);
   }
-  const payload: SharePayload = {
-    v: 1,
+  const payload = {
+    v: 2,
     d: [...dict.keys()],
-    ...(target ? { t: target } : {}),
-    ...(inventory.length ? { i: inventory } : {}),
-    a: [...autoRoots],
-    s: selections,
+    c: cards,
+    w: wires,
     g: tagSelections,
-    c: [...(state.collapsed ?? [])],
   };
   const packed = deflateSync(strToU8(JSON.stringify(payload)));
   return `x${encodeUrlSafe(btoa(u8ToBinary(packed)))}`;
 }
 
-function decodeCalcSharePayload(text: string): CalculatorState | null {
-  const bin = atob(decodeUrlSafe(text.slice(1)));
-  const packed = Uint8Array.from(bin, (c) => c.charCodeAt(0));
-  const payload = JSON.parse(strFromU8(inflateSync(packed))) as SharePayload;
-  if (payload.v !== 1 || !Array.isArray(payload.d)) return null;
-  const dict = payload.d;
-  const id = (idx: unknown): string | null =>
-    typeof idx === 'number' && idx >= 0 && idx < dict.length
-      ? dict[idx]!
-      : null;
-  const material = (row: unknown): CalcMaterial | null => {
-    if (!Array.isArray(row)) return null;
-    const rowId = id(row[0]);
-    if (!rowId) return null;
-    return {
-      id: rowId,
-      kind: row[1] === 1 ? ('fluid' as const) : ('item' as const),
-      amount: Number(row[2]) || 1,
-    };
-  };
-
-  const targetRow = Array.isArray(payload.t?.[0])
-    ? payload.t[0]
-    : payload.t;
-  const targetMat = material(targetRow);
-  const target: CalculatorTarget | null = targetMat
-    ? { id: targetMat.id, kind: targetMat.kind, amount: targetMat.amount }
-    : null;
-  if (!target) return null;
-  const inventory = Array.isArray(payload.i)
-    ? payload.i.flatMap((row): CalcMaterial[] => {
-        const mat = material(row);
-        return mat ? [mat] : [];
-      })
-    : [];
-  const selections: Record<string, string> = {};
-  for (const [key, value] of Object.entries(payload.s ?? {})) {
-    const recipeId = id(value);
-    if (!recipeId) continue;
-    if (key.startsWith('#')) {
-      const materialId = id(Number(key.slice(1)));
-      if (materialId) selections[materialId] = recipeId;
-    } else {
-      selections[key] = recipeId;
-    }
-  }
-  const tagSelections: Record<string, string> = {};
-  for (const [tagIdx, memberIdx] of Object.entries(payload.g ?? {})) {
-    const tagId = id(Number(tagIdx));
-    const memberId = id(memberIdx);
-    if (tagId && memberId) tagSelections[tagId] = memberId;
-  }
-  const collapsed = Array.isArray(payload.c)
-    ? payload.c.filter((p): p is string => typeof p === 'string')
-    : [];
-  const auto = Array.isArray(payload.a)
-    ? payload.a.filter((p): p is string => typeof p === 'string')
-    : [];
-  return {
-    target,
-    ...(inventory.length ? { inventory } : {}),
-    selections,
-    tagSelections,
-    ...(collapsed.length ? { collapsed } : {}),
-    ...(auto.length ? { auto } : {}),
-  };
-}
-
 export function decodeCalcState(encoded: string): CalculatorState | null {
-  if (!encoded.trim()) return null;
+  const text = encoded.trim();
+  if (!text.startsWith('x')) return null;
   try {
-    const text = encoded.trim();
-    if (text.startsWith('x')) return decodeCalcSharePayload(text);
-    return null;
+    const bin = atob(decodeUrlSafe(text.slice(1)));
+    const packed = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+    const payload = JSON.parse(strFromU8(inflateSync(packed))) as {
+      v?: number;
+      d?: string[];
+      c?: number[][];
+      w?: number[][];
+      g?: Record<string, number>;
+    };
+    if (payload.v !== 2 || !Array.isArray(payload.d)) return null;
+    const dict = payload.d;
+    const id = (idx: unknown): string | null =>
+      typeof idx === 'number' && idx >= 0 && idx < dict.length
+        ? dict[idx]!
+        : null;
+    const cards: CalcCard[] = [];
+    for (const [index, row] of (payload.c ?? []).entries()) {
+      if (!Array.isArray(row)) continue;
+      const materialId = id(row[0]);
+      if (!materialId) continue;
+      const kind = row[1] === 1 ? 'fluid' : 'item';
+      const recipeId = row[2] === -1 ? null : id(row[2]);
+      cards.push({
+        id: `c${index}`,
+        materialId,
+        kind,
+        recipeId: recipeId ?? null,
+        crafts: Number(row[3]) || 1,
+        pos:
+          row[6] === 1
+            ? { x: Number(row[4]) || 0, y: Number(row[5]) || 0 }
+            : undefined,
+      });
+    }
+    const wires: CalcWire[] = [];
+    for (const row of payload.w ?? []) {
+      if (!Array.isArray(row)) continue;
+      const from = cards[row[0]!];
+      const to = cards[row[1]!];
+      if (!from || !to) continue;
+      wires.push({
+        from: from.id,
+        to: to.id,
+        input: Number(row[2]) || 0,
+        out: Number(row[3]) || undefined,
+        amount: Number(row[4]) || undefined,
+      });
+    }
+    const tagSelections: Record<string, string> = {};
+    for (const [tagIdx, memberIdx] of Object.entries(payload.g ?? {})) {
+      const tagId = id(Number(tagIdx));
+      const memberId = id(memberIdx);
+      if (tagId && memberId) tagSelections[tagId] = memberId;
+    }
+    return { cards, wires, tagSelections };
   } catch {
     return null;
   }
 }
+

package/src/lib/calc/worker/api.ts

@@ -1,12 +1,12 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
-import { runFill } from './fill';
 import type { FlushHandler, ResolveInput } from './protocol';
 import { runResolve } from './resolve';
 import { resetWorkerState, state } from './state';
 
 export const api = {
   async init(
-    nextDataset: string,
+    nextDataset: DatasetRef,
     nextCatalog: RecipeCompactIndex,
     flushHandler: FlushHandler,
   ) {
@@ -14,20 +14,12 @@ export const api = {
     state.onFlush = flushHandler;
   },
   async resolve(input: ResolveInput) {
-
     state.resolveGen += 1;
-    state.fillGen += 1;
     await runResolve(input);
   },
-  async fill(input: ResolveInput & { roots: string[] }) {
-    state.fillGen += 1;
-    state.resolveGen += 1;
-    return runFill(input);
-  },
-
   async invalidate() {
     state.resolveGen += 1;
-    state.fillGen += 1;
     state.epoch += 1;
   },
 };
+

package/src/lib/calc/worker/fetch.ts

@@ -63,3 +63,4 @@ export async function fetchWanted(
   }
   return progressed;
 }
+

package/src/lib/calc/worker/flush.ts

@@ -1,7 +1,9 @@
 import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
 import type { RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
-import type { CalcMaterial, CalcRecipe, TagResolution } from '@terrafirmagreg-team/recipe/types/calc';
-import { flattenTree, mergeAmounts, type CalcGoal } from '@terrafirmagreg-team/recipe/lib/calc/tree';
+import type {
+  CalcRecipe,
+  TagResolution,
+} from '@terrafirmagreg-team/recipe/types/calc';
 import { state } from './state';
 
 export function createFlush() {
@@ -17,22 +19,8 @@ export function createFlush() {
 
 export type Pending = ReturnType<typeof createFlush>;
 
-function deriveSummary(goals: CalcGoal[]): {
-  raw: CalcMaterial[];
-  catalysts: CalcMaterial[];
-} {
-  const raw: CalcMaterial[] = [];
-  const catalysts: CalcMaterial[] = [];
-  for (const goal of goals) {
-    const flat = flattenTree(goal.node);
-    raw.push(...flat.cost);
-    catalysts.push(...flat.catalysts);
-  }
-  return { raw: mergeAmounts(raw), catalysts: mergeAmounts(catalysts) };
-}
-
-export function postFlush(pending: Pending, goals?: CalcGoal[]) {
-  if (!pending.dirty && !goals) return;
+export function postFlush(pending: Pending) {
+  if (!pending.dirty) return;
   pending.dirty = false;
   state.onFlush({
     epoch: state.epoch,
@@ -41,8 +29,6 @@ export function postFlush(pending: Pending, goals?: CalcGoal[]) {
     recipes: [...pending.recipes],
     bodies: [...pending.bodies],
     dead: [...pending.dead],
-    goals,
-    ...(goals ? { summary: deriveSummary(goals) } : {}),
   });
   pending.out.clear();
   pending.tag.clear();
@@ -50,3 +36,4 @@ export function postFlush(pending: Pending, goals?: CalcGoal[]) {
   pending.bodies.clear();
   pending.dead.clear();
 }
+

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

@@ -1,4 +1,3 @@
-
 import { expose } from 'comlink';
 import { api } from './api';
 
@@ -6,3 +5,4 @@ export type CalcWorkerApi = typeof api;
 export type { CalcWorkerFlush } from './protocol';
 
 expose(api);
+

package/src/lib/calc/worker/protocol.ts

@@ -1,32 +1,35 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
 import type { RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
 import type {
-  CalcMaterial,
   CalcRecipe,
-  CalculatorTarget,
   TagResolution,
 } from '@terrafirmagreg-team/recipe/types/calc';
-import type { CalcGoal } from '@terrafirmagreg-team/recipe/lib/calc/tree';
 
 export type ResolveInput = {
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-  selections: Record<string, string>;
-  tagSelections: Record<string, string>;
-  collapsed: string[];
-  auto: string[];
+  materials?: string[];
+  recipes?: string[];
+  tags?: string[];
 };
 
 export type CalcWorkerFlush = {
-
   epoch: number;
   out: [string, RecipeCompactRow[]][];
   tag: [string, TagResolution][];
   recipes: [string, CalcRecipe][];
   bodies: [string, Recipe][];
   dead: string[];
-  goals?: CalcGoal[];
-  summary?: { raw: CalcMaterial[]; catalysts: CalcMaterial[] };
 };
 
-export type FlushHandler = (flush: CalcWorkerFlush) => void;
+export type FlushHandler = (msg: CalcWorkerFlush) => void;
+
+export type CalcWorkerApi = {
+  init(
+    dataset: DatasetRef,
+    catalog: unknown,
+    flushHandler: FlushHandler,
+  ): Promise<void>;
+  resolve(input: ResolveInput): Promise<void>;
+  invalidate(): Promise<void>;
+};
+

package/src/lib/calc/worker/resolve.ts

@@ -1,101 +1,49 @@
-import type { CalcNode } from '@terrafirmagreg-team/recipe/types/calc';
-import { pickAutoRecipe } from '@terrafirmagreg-team/recipe/lib/calc/resolve';
-import {
-  AUTO_NODE_BUDGET,
-  buildGoal,
-  type BuildContext,
-  type CalcGoal,
-} from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import { createWorkerSummaries, fetchWanted } from './fetch';
+import { fetchWanted } from './fetch';
 import { createFlush, postFlush } from './flush';
 import type { ResolveInput } from './protocol';
 import { state } from './state';
 
 export async function runResolve(input: ResolveInput) {
   const gen = state.resolveGen;
-  const summaries = createWorkerSummaries(state.recipeMap);
   const pending = createFlush();
-  const collapsed = new Set(input.collapsed);
-  const ctx = (
-    autoRoots: readonly string[],
-  ): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => ({
-    recipeMap: state.recipeMap,
-    getRecipesForItem: summaries.get,
-    selections: input.selections,
-    tagSelections: input.tagSelections,
-    tagMembers: (id) => state.tagMap.get(id),
-    collapsed,
-    autoRoots,
-    autoBudget: { left: AUTO_NODE_BUDGET },
-    recipesResolved: (id) => state.outMap.has(id),
-    deadIds: state.deadIds,
-  });
-  const localRecipes = state.recipeMap;
-  let latestGoals: CalcGoal[] | undefined;
-  for (let iter = 0; iter < 200; iter += 1) {
+  const wantedRecipes = new Set(
+    (input.recipes ?? []).filter(
+      (id) => id && !state.recipeMap.has(id) && !state.deadIds.has(id),
+    ),
+  );
+  const wantedOut = new Set(
+    (input.materials ?? []).filter((id) => id && !state.outMap.has(id)),
+  );
+  const wantedTag = new Set(
+    (input.tags ?? []).filter((id) => id && !state.tagMap.has(id)),
+  );
+  for (let iter = 0; iter < 50; iter += 1) {
     if (gen !== state.resolveGen) return;
-    const wanted = new Set<string>();
-    const wantedOut = new Set<string>();
-    const wantedTag = new Set<string>();
-    const built: CalcGoal[] = [];
-    if (input.target) {
-      const goalCtx = ctx(input.auto);
-      const goal = buildGoal(input.target, goalCtx, 'g0', input.inventory);
-      built.push(goal);
-      const walk = (n: CalcNode, ancestors: Set<string>): void => {
-        const next =
-          n.recipe && n.need > 0
-            ? new Set(ancestors).add(`${n.kind}:${n.materialId}`)
-            : ancestors;
-        if (n.tagId && !state.tagMap.has(n.tagId)) wantedTag.add(n.tagId);
-        if (!state.outMap.has(n.materialId)) wantedOut.add(n.materialId);
-        if (n.recipe) {
-          for (const entry of n.recipe.inputs) {
-            if (entry.tagId && !state.tagMap.has(entry.tagId)) {
-              wantedTag.add(entry.tagId);
-            }
-          }
-        } else if (n.auto) {
-          const autoPick = pickAutoRecipe(
-            n,
-            input.selections,
-            ancestors,
-            goalCtx,
-          );
-          if (
-            autoPick.pick &&
-            !localRecipes.has(autoPick.pick) &&
-            !state.deadIds.has(autoPick.pick)
-          ) {
-            wanted.add(autoPick.pick);
-          }
-          for (const id of autoPick.wantRecipes) {
-            if (!localRecipes.has(id) && !state.deadIds.has(id)) wanted.add(id);
-          }
-          for (const id of autoPick.wantOut) {
-            if (!state.outMap.has(id)) wantedOut.add(id);
-          }
-        }
-        for (const child of n.children) walk(child, next);
-      };
-      walk(goal.node, new Set());
-    }
-    for (const id of Object.values(input.selections)) {
-      if (id && !localRecipes.has(id) && !state.deadIds.has(id)) wanted.add(id);
-    }
-    latestGoals = built;
-    if (!wanted.size && !wantedOut.size && !wantedTag.size) break;
+    if (!wantedRecipes.size && !wantedOut.size && !wantedTag.size) break;
     const progressed = await fetchWanted(
       pending,
-      wanted,
+      wantedRecipes,
       wantedOut,
       wantedTag,
-      localRecipes,
+      state.recipeMap,
     );
     if (gen !== state.resolveGen) return;
     if (!progressed) break;
-    summaries.clear();
-    if (iter % 5 === 4) postFlush(pending, latestGoals);
+    for (const id of input.tags ?? []) {
+      if (id && !state.tagMap.has(id)) wantedTag.add(id);
+    }
+    wantedRecipes.forEach((id) => {
+      if (state.recipeMap.has(id) || state.deadIds.has(id)) {
+        wantedRecipes.delete(id);
+      }
+    });
+    wantedOut.forEach((id) => {
+      if (state.outMap.has(id)) wantedOut.delete(id);
+    });
+    wantedTag.forEach((id) => {
+      if (state.tagMap.has(id)) wantedTag.delete(id);
+    });
   }
-  postFlush(pending, latestGoals);
+  postFlush(pending);
 }
+

package/src/lib/calc/worker/state.ts

@@ -1,10 +1,11 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
 import type { RecipeCompactIndex, RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
 import type { CalcRecipe, TagResolution } from '@terrafirmagreg-team/recipe/types/calc';
 import type { FlushHandler } from './protocol';
 
 export type CalcWorkerState = {
-  dataset: string;
+  dataset: DatasetRef;
   catalog: RecipeCompactIndex | null;
   onFlush: FlushHandler;
   outMap: Map<string, RecipeCompactRow[]>;
@@ -15,11 +16,10 @@ export type CalcWorkerState = {
 
   epoch: number;
   resolveGen: number;
-  fillGen: number;
 };
 
 export const state: CalcWorkerState = {
-  dataset: '',
+  dataset: { id: '' },
   catalog: null,
   onFlush: () => {},
   outMap: new Map(),
@@ -29,17 +29,15 @@ export const state: CalcWorkerState = {
   deadIds: new Set(),
   epoch: 0,
   resolveGen: 0,
-  fillGen: 0,
 };
 
 export function resetWorkerState(
-  nextDataset: string,
+  nextDataset: DatasetRef,
   nextCatalog: RecipeCompactIndex,
 ) {
   state.dataset = nextDataset;
   state.catalog = nextCatalog;
   state.resolveGen += 1;
-  state.fillGen += 1;
   state.epoch += 1;
   state.outMap.clear();
   state.tagMap.clear();
@@ -47,3 +45,4 @@ export function resetWorkerState(
   state.bodyMap.clear();
   state.deadIds.clear();
 }
+

package/src/{components/cards/card/model.ts → lib/card-model.ts}

@@ -62,3 +62,4 @@ export function textInStrip(
     widget.x < geo.right
   );
 }
+