@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

package/src/lib/calc/flow.ts

@@ -1,7 +1,13 @@
+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 type { CalcKind, CalcNode } from '@terrafirmagreg-team/recipe/types/calc';
-import type { CalcGoal } from '@terrafirmagreg-team/recipe/lib/calc/tree';
+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;
@@ -14,56 +20,61 @@ const CALC_MINI_W = 96;
 const CALC_MINI_TAG_H = 84;
 
 export type CalcViewMode = 'mini' | 'normal' | 'detailed';
-export type CalcDirection = 'vertical' | 'horizontal';
-export type CalcEdgeStyle =
-  | 'default'
-  | 'straight'
-  | 'step'
-  | 'smoothstep'
-  | 'circuit';
 export type CalcFarMode = 'full' | 'preview' | 'hidden';
 
-export type CalcDensity = number;
-
-const DENSITY_GAP_MIN = { x: 8, y: 12, goal: 28 };
-const DENSITY_GAP_MAX = { x: 14, y: 22, goal: 44 };
-
-export function densityGaps(density: CalcDensity) {
-  const d = Math.min(1, Math.max(0, density || 0));
-  return {
-    x: DENSITY_GAP_MIN.x + (DENSITY_GAP_MAX.x - DENSITY_GAP_MIN.x) * d,
-    y: DENSITY_GAP_MIN.y + (DENSITY_GAP_MAX.y - DENSITY_GAP_MIN.y) * d,
-    goal:
-      DENSITY_GAP_MIN.goal +
-      (DENSITY_GAP_MAX.goal - DENSITY_GAP_MIN.goal) * d,
-  };
-}
+export const GRID_GAPS = { x: 14, y: 24, goal: 48 };
 
 export type CalcTier = 'dot' | 'far' | 'near';
 
 export type CalcFlowData = {
   node: CalcNode;
-  dataset: string;
+  dataset: DatasetRef;
   mode: CalcViewMode;
-  direction: CalcDirection;
-
-  missing?: CalcNode[];
   recipeBody: (recipeId: string) => Recipe | undefined;
-  onSelectRecipe: (materialId: string, recipeId: string | null) => void;
+  onSelectRecipe: (cardId: string, recipeId: string | null) => void;
   onSelectTagMember: (tagId: string, memberId: string) => void;
-
   onRequestPicker: (node: CalcNode) => void;
-
   onRequestMemberPicker: (node: CalcNode) => void;
-
-  onSetTarget: (materialId: string, kind: CalcKind) => void;
-
-  onAddStock: (materialId: string, kind: CalcKind) => 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;
-  onFillNode: (path: string) => void;
-  onCollapseNode: (path: string) => void;
-
-  onRemoveTarget: (flowId: string) => 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;
 };
@@ -75,86 +86,115 @@ 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, h: CALC_MINI_TAG_H };
+    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),
+      w: Math.max(CALC_NODE_W, body.w + 16) + margin,
       h: CALC_NODE_H + body.h + 6,
     };
   }
-  return { w: CALC_NODE_W, h: CALC_NODE_H };
+  return { w: CALC_NODE_W + margin, h: CALC_NODE_H };
 }
 
-export function goalsToFlow(
-  goals: CalcGoal[],
+export function cardsToFlow(
+  nodes: CalcNode[],
+  wires: readonly CalcWire[],
   data: Omit<CalcFlowData, 'node'>,
-  edgeStyle: CalcEdgeStyle = 'default',
+  flows?: readonly (number | undefined)[],
 ): { nodes: AnyCalcFlowNode[]; edges: Edge[] } {
-  const nodes: AnyCalcFlowNode[] = [];
-  const edges: Edge[] = [];
-  const walk = (node: CalcNode, path: string): void => {
+  const flowNodes: AnyCalcFlowNode[] = nodes.map((node) => {
     const { w, h } = nodeSize(node, {
       mode: data.mode,
       recipeBody: data.recipeBody,
     });
-    const missing = node.children.filter((child) => child.collapsed);
-    nodes.push({
-      id: path,
+    return {
+      id: node.id,
       type: 'calcMaterial',
       position: { x: 0, y: 0 },
       width: w,
       height: h,
-      data: { ...data, node, ...(missing.length ? { missing } : {}) },
-    });
-    node.children.forEach((child, index) => {
-      if (child.collapsed) return;
-      const childPath = child.path ?? `${path}/${index}`;
-      edges.push({
-        id: `${childPath}->${path}`,
-        source: childPath,
-        target: path,
+      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:
-          [
-            child.catalyst ? 'calc-edge--catalyst' : '',
-            edgeStyle === 'circuit' ? 'calc-edge--circuit' : '',
-          ]
-            .filter(Boolean)
-            .join(' ') || undefined,
-        data: { route: edgeStyle },
-      });
-      walk(child, childPath);
-    });
-  };
-  goals.forEach((goal, gi) => walk(goal.node, `g${gi}`));
-  return { nodes, edges };
+        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.amount === b.amount &&
-    a.batches === b.batches &&
-    a.satisfied === b.satisfied &&
-    a.need === b.need &&
+    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.catalyst === b.catalyst &&
-    a.collapsed === b.collapsed &&
+    a.products === b.products &&
     a.recipe?.recipeId === b.recipe?.recipeId &&
     a.recipe?.category === b.recipe?.category &&
     a.tagId === b.tagId &&
-    a.path === b.path &&
-    a.expandable === b.expandable &&
-    a.auto === b.auto &&
     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.children.length === b.children.length &&
     a.availableRecipes.length === b.availableRecipes.length &&
     a.availableRecipes.every(
       (row, index) =>
@@ -165,38 +205,29 @@ function sameCalcNode(a: CalcNode, b: CalcNode): boolean {
   );
 }
 
-function sameMissing(
-  a: CalcNode[] | undefined,
-  b: CalcNode[] | undefined,
-): boolean {
-  if ((a?.length ?? 0) !== (b?.length ?? 0)) return false;
-  return (a ?? []).every(
-    (node, i) =>
-      node.path === b![i]!.path &&
-      node.materialId === b![i]!.materialId &&
-      node.need === b![i]!.need &&
-      node.availableRecipes.length === b![i]!.availableRecipes.length,
-  );
-}
-
 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.direction === b.direction &&
-    sameMissing(a.missing, b.missing) &&
-    a.onFillNode === b.onFillNode &&
-    a.onCollapseNode === b.onCollapseNode &&
-    a.onRemoveTarget === b.onRemoveTarget &&
     a.recipeBody === b.recipeBody &&
     a.onSelectRecipe === b.onSelectRecipe &&
     a.onSelectTagMember === b.onSelectTagMember &&
     a.onRequestPicker === b.onRequestPicker &&
     a.onRequestMemberPicker === b.onRequestMemberPicker &&
-    a.onSetTarget === b.onSetTarget &&
-    a.onAddStock === b.onAddStock &&
+    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
   );
@@ -258,8 +289,12 @@ export function reconcileCalcEdges(
       kept &&
       kept.source === edge.source &&
       kept.target === edge.target &&
+      kept.sourceHandle === edge.sourceHandle &&
+      kept.targetHandle === edge.targetHandle &&
       kept.className === edge.className &&
-      (kept.data?.route ?? 'default') === (edge.data?.route ?? 'default') &&
+      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(
@@ -277,3 +312,4 @@ export function reconcileCalcEdges(
   });
   return changed ? out : prev;
 }
+

package/src/lib/calc/focus.ts

@@ -12,3 +12,4 @@ export function onCalcFocusRequest(listener: Listener): () => void {
     listeners.delete(listener);
   };
 }
+

package/src/lib/calc/meta.ts

@@ -1,9 +1,10 @@
+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: string;
+  dataset: DatasetRef;
   lang: string;
   langMap?: Record<string, string>;
   iconItems?: IconItem[];
@@ -13,3 +14,4 @@ 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';
+

package/src/lib/calc/pack.ts

@@ -1,184 +1,77 @@
-import potpack, { type PotpackBox } from 'potpack';
 import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
-import type { CalcNode } from '@terrafirmagreg-team/recipe/types/calc';
-import type { CalcGoal } from '@terrafirmagreg-team/recipe/lib/calc/tree';
+import type {
+  CalcNode,
+  CalcWire,
+} from '@terrafirmagreg-team/recipe/types/calc';
 import {
   nodeSize,
-  type CalcDirection,
   type CalcViewMode,
 } from '@terrafirmagreg-team/recipe/lib/calc/flow';
 
 export type CalcPackOptions = {
   mode: CalcViewMode;
-  direction: CalcDirection;
   gaps: { x: number; y: number; goal: number };
   recipeBody: (recipeId: string) => Recipe | undefined;
 };
 
-type Packed = {
-  node: CalcNode;
-  path: string;
-
-  fragW: number;
-
-  fragH: number;
-
-  kidRows: Packed[][];
-
-  wrapped: Packed[];
-};
-
-export function packGoals(
-  goals: CalcGoal[],
+export function layoutCards(
+  nodes: CalcNode[],
+  wires: readonly CalcWire[],
   options: CalcPackOptions,
 ): Map<string, { x: number; y: number }> {
-  const vertical = options.direction !== 'horizontal';
   const { gaps } = options;
   const sizeOf = (node: CalcNode) =>
     nodeSize(node, {
       mode: options.mode,
       recipeBody: options.recipeBody,
     });
-  const cross = (node: CalcNode) =>
-    vertical ? sizeOf(node).w : sizeOf(node).h;
-  const main = (node: CalcNode) =>
-    vertical ? sizeOf(node).h : sizeOf(node).w;
-
-  const measure = (
-    node: CalcNode,
-    path: string,
-    budget: number,
-    rowCap: number,
-  ): Packed => {
-    const kids = node.children
-      .filter((child) => !child.collapsed)
-      .map((child, index) =>
-        measure(child, child.path ?? `${path}/${index}`, budget, rowCap),
-      );
-    const bands: Packed[][] = [];
-    let row: Packed[] = [];
-    let rowW = 0;
-    for (const kid of kids) {
-      if (row.length && rowW + gaps.x + kid.fragW > rowCap) {
-        bands.push(row);
-        row = [];
-        rowW = 0;
-      }
-      rowW += (row.length ? gaps.x : 0) + kid.fragW;
-      row.push(kid);
-    }
-    if (row.length) bands.push(row);
-
-    const kidRows: Packed[][] = [];
-    const wrapped: Packed[] = [];
-    let used = main(node);
-    for (const band of bands) {
-      const bandH = Math.max(...band.map((kid) => kid.fragH));
-      if (kidRows.length && used + gaps.y + bandH > budget) {
-        wrapped.push(...band);
-        continue;
-      }
-      kidRows.push(band);
-      used += gaps.y + bandH;
-    }
-    const widest = kidRows.reduce(
-      (acc, band) =>
-        Math.max(
-          acc,
-          band.reduce((sum, kid) => sum + kid.fragW, 0) +
-            gaps.x * (band.length - 1),
-        ),
-      0,
-    );
-    return {
-      node,
-      path,
-      fragW: Math.max(cross(node), widest),
-      fragH: used,
-      kidRows,
-      wrapped,
-    };
-  };
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const consumers = new Map<string, string[]>();
+  const suppliers = new Map<string, string[]>();
+  for (const wire of wires) {
+    if (!byId.has(wire.from) || !byId.has(wire.to)) continue;
+    consumers.set(wire.from, [...(consumers.get(wire.from) ?? []), wire.to]);
+    suppliers.set(wire.to, [...(suppliers.get(wire.to) ?? []), wire.from]);
+  }
 
-  const collect = (tree: Packed, out: Packed[]) => {
-    for (const kid of tree.wrapped) {
-      out.push(kid);
-      collect(kid, out);
-    }
-    for (const row of tree.kidRows) {
-      for (const kid of row) collect(kid, out);
+  const depth = new Map<string, number>();
+  const visit = (id: string, trail: Set<string>): number => {
+    const hit = depth.get(id);
+    if (hit !== undefined) return hit;
+    if (trail.has(id)) return 0;
+    trail.add(id);
+    let d = 0;
+    for (const next of suppliers.get(id) ?? []) {
+      d = Math.max(d, visit(next, trail) + 1);
     }
+    trail.delete(id);
+    depth.set(id, d);
+    return d;
   };
-  const measureAll = (budget: number, rowCap: number) =>
-    goals.map((goal, gi) => {
-      const root = measure(goal.node, `g${gi}`, budget, rowCap);
-      const columns = [root];
-      collect(root, columns);
-      return columns;
-    });
+  for (const node of nodes) visit(node.id, new Set());
 
-  let totalArea = 0;
-  let maxMain = 0;
-  for (const columns of measureAll(Infinity, Infinity)) {
-    for (const column of columns) {
-      totalArea +=
-        (column.fragW + gaps.goal) * (column.fragH + gaps.goal);
-      maxMain = Math.max(maxMain, main(column.node));
-    }
+  const lanes = new Map<number, CalcNode[]>();
+  for (const node of nodes) {
+    const d = depth.get(node.id) ?? 0;
+    lanes.set(d, [...(lanes.get(d) ?? []), node]);
   }
-
-  const target = Math.max(Math.sqrt(totalArea), maxMain * 2);
-  const sheets = measureAll(target, target);
-
   const positions = new Map<string, { x: number; y: number }>();
-  const place = (
-    tree: Packed,
-    left: number,
-    top: number,
-    rowH: number,
-  ) => {
-    positions.set(tree.path, {
-      x: vertical ? left + tree.fragW / 2 : top + rowH / 2,
-      y: vertical ? top + rowH / 2 : left + tree.fragW / 2,
-    });
-    let bandTop = top + rowH + gaps.y;
-    for (const row of tree.kidRows) {
-      const rowW =
-        row.reduce((sum, kid) => sum + kid.fragW, 0) +
-        gaps.x * (row.length - 1);
-      const cardRowH = Math.max(...row.map((kid) => main(kid.node)));
-      const bandH = Math.max(...row.map((kid) => kid.fragH));
-      let cursor = left + (tree.fragW - rowW) / 2;
-      for (const kid of row) {
-        place(kid, cursor, bandTop, cardRowH);
-        cursor += kid.fragW + gaps.x;
-      }
-      bandTop += bandH + gaps.y;
-    }
-  };
-
-  type FragBox = PotpackBox & { frag: Packed };
-  const packedSheets: (PotpackBox & { boxes: FragBox[] })[] = sheets.map(
-    (columns) => {
-      const boxes: FragBox[] = columns.map((frag) => ({
-        w: frag.fragW + gaps.goal,
-        h: frag.fragH + gaps.goal,
-        frag,
-      }));
-      const sheet = potpack(boxes);
-      return { w: sheet.w + gaps.goal, h: sheet.h + gaps.goal, boxes };
-    },
-  );
-  potpack(packedSheets);
-  for (const sheet of packedSheets) {
-    for (const box of sheet.boxes) {
-      place(
-        box.frag,
-        (sheet.x ?? 0) + (box.x ?? 0),
-        (sheet.y ?? 0) + (box.y ?? 0),
-        main(box.frag.node),
-      );
+  let mainCursor = 0;
+  const ordered = [...lanes.entries()].sort(([a], [b]) => a - b);
+  for (const [, lane] of ordered) {
+    let cross = 0;
+    let laneMain = 0;
+    for (const node of lane) {
+      const { w, h } = sizeOf(node);
+      positions.set(node.id, {
+        x: mainCursor + w / 2,
+        y: cross + h / 2,
+      });
+      cross += h + gaps.x;
+      laneMain = Math.max(laneMain, w);
     }
+    mainCursor += laneMain + gaps.y + gaps.goal;
   }
   return positions;
 }
+

package/src/lib/calc/ports.ts

@@ -0,0 +1,43 @@
+export const PORT_SIZE = 20;
+export const PORT_GAP = 2;
+export const PORT_STEP = PORT_SIZE + PORT_GAP;
+export const PORT_OUT = PORT_SIZE / 2;
+export const PORT_IN = PORT_OUT + 2;
+
+export const railSpans = new Map<
+  string,
+  {
+    inStart?: number;
+    inRows?: number;
+    outStart?: number;
+    outRows?: number;
+  }
+>();
+
+export function portAnchorPoint(
+  node: { position: { x: number; y: number }; width?: number; height?: number },
+  side: 'src' | 'tgt',
+  index = 0,
+  count = 1,
+): { x: number; y: number } {
+  const w = node.width ?? 0;
+  const h = node.height ?? 0;
+  const span =
+    'id' in node && typeof node.id === 'string'
+      ? railSpans.get(node.id)
+      : undefined;
+  const start = (side === 'tgt' ? span?.inStart : span?.outStart) ?? 0;
+  const measured = side === 'tgt' ? span?.inRows : span?.outRows;
+  const maxRows = Math.max(1, Math.floor((h - 4) / PORT_STEP));
+  const rows = Math.max(1, Math.min(count, measured ?? maxRows));
+  const row = Math.max(
+    0,
+    Math.min(index - start + (start > 0 ? 1 : 0), rows - 1),
+  );
+  const sign = side === 'src' ? 1 : -1;
+  return {
+    x: node.position.x + sign * (w / 2),
+    y: node.position.y + (row - (rows - 1) / 2) * PORT_STEP,
+  };
+}
+