@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

package/src/hooks/calc/use-amounts.ts

@@ -2,34 +2,23 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react';
 import type {
-  CalcMaterial,
+  CalcCard,
+  CalcWire,
   CalculatorState,
-  CalculatorTarget,
 } from '@terrafirmagreg-team/recipe/types/calc';
 
-type PendingAmounts = {
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-};
-
 export function useCalcAmounts({
-  target,
-  inventory,
-  persist,
-  selections,
+  cards,
+  wires,
   tagSelections,
-  collapsed,
-  auto,
+  persist,
 }: {
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-  persist: (next: CalculatorState) => void;
-  selections: Record<string, string>;
+  cards: CalcCard[];
+  wires: CalcWire[];
   tagSelections: Record<string, string>;
-  collapsed: string[];
-  auto: string[];
+  persist: (next: CalculatorState) => void;
 }) {
-  const [pending, setPending] = useState<PendingAmounts | null>(null);
+  const [pending, setPending] = useState<CalcCard[] | null>(null);
   const amountTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
 
   useEffect(
@@ -39,63 +28,37 @@ export function useCalcAmounts({
     [],
   );
 
-  const flushAmounts = useCallback((): PendingAmounts => {
+  const flushAmounts = useCallback((): CalcCard[] => {
     if (amountTimer.current) {
       clearTimeout(amountTimer.current);
       amountTimer.current = undefined;
     }
-    if (!pending) return { target, inventory };
+    if (!pending) return cards;
     setPending(null);
     return pending;
-  }, [pending, target, inventory]);
+  }, [pending, cards]);
 
-  const schedule = useCallback(
-    (next: PendingAmounts) => {
+  const onCrafts = useCallback(
+    (cardId: string, crafts: number) => {
+      const base = pending ?? cards;
+      const next = base.map((card) =>
+        card.id === cardId ? { ...card, crafts: Math.max(1, crafts) } : card,
+      );
       setPending(next);
       if (amountTimer.current) clearTimeout(amountTimer.current);
       amountTimer.current = setTimeout(() => {
         amountTimer.current = undefined;
         setPending(null);
-        persist({
-          target: next.target,
-          inventory: next.inventory,
-          selections,
-          tagSelections,
-          collapsed,
-          auto,
-        });
+        persist({ cards: next, wires, tagSelections });
       }, 300);
     },
-    [persist, selections, tagSelections, collapsed, auto],
-  );
-
-  const onAmount = useCallback(
-    (amount: number) => {
-      const base = pending ?? { target, inventory };
-      if (!base.target) return;
-      schedule({ ...base, target: { ...base.target, amount } });
-    },
-    [pending, target, inventory, schedule],
-  );
-
-  const onStockAmount = useCallback(
-    (index: number, amount: number) => {
-      const base = pending ?? { target, inventory };
-      schedule({
-        ...base,
-        inventory: base.inventory.map((row, i) =>
-          i === index ? { ...row, amount } : row,
-        ),
-      });
-    },
-    [pending, target, inventory, schedule],
+    [pending, cards, persist, wires, tagSelections],
   );
 
   return {
-    displayTarget: pending?.target ?? target,
-    displayInventory: pending?.inventory ?? inventory,
+    displayCards: pending ?? cards,
     flushAmounts,
-    onAmount,
-    onStockAmount,
+    onCrafts,
   };
 }
+

package/src/hooks/calc/use-data.ts

@@ -1,21 +1,23 @@
 'use client';
 
-import { useCallback, useEffect, useMemo, useRef } from 'react';
-import { encodeCalcShare } from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import { pickAutoRecipe } from '@terrafirmagreg-team/recipe/lib/calc/resolve';
+import { useCallback, useMemo } from 'react';
+import { encodeCalcState } from '@terrafirmagreg-team/recipe/lib/calc/tree';
 import {
-  calcStorageKey,
-  updateCalcTab,
-} from '@terrafirmagreg-team/recipe/lib/calc/storage';
+  summaryCacheFor,
+  summarizeRecipes,
+} from '@terrafirmagreg-team/recipe/lib/calc/resolve';
+import { buildScheme, schemeSummary } from '@terrafirmagreg-team/recipe/lib/calc/scheme';
+import { calcStorageKey } from '@terrafirmagreg-team/recipe/lib/calc/storage';
 import type { RecipeSession } from '@terrafirmagreg-team/recipe/types';
-import type { CalcNode, CalculatorState } from '@terrafirmagreg-team/recipe/types/calc';
+import type {
+  CalcKind,
+  CalcRecipeSummary,
+} from '@terrafirmagreg-team/recipe/types/calc';
 import { useCalcStorage } from './use-storage';
 import { useCalcShare } from './use-share';
 import { useCalcMaps } from './use-maps';
 import { useCalcWorker } from './use-worker';
-import { useCalcDerived } from './use-derived';
 import { useCalcResolver } from './use-resolver';
-import { useFillTree } from './use-fill';
 import { useRecipeDefaults } from './use-defaults';
 
 export function useCalcData(session: RecipeSession) {
@@ -48,222 +50,130 @@ export function useCalcData(session: RecipeSession) {
   const {
     outMap: dataOutMap,
     recipeMap: dataRecipeMap,
+    tagMap: dataTagMap,
     deadIds: dataDeadIds,
   } = data;
 
-  const selections = useMemo(
-    () => calcState?.selections ?? {},
-    [calcState],
-  );
+  const cards = useMemo(() => calcState?.cards ?? [], [calcState]);
+  const wires = useMemo(() => calcState?.wires ?? [], [calcState]);
   const tagSelections = useMemo(
     () => calcState?.tagSelections ?? {},
     [calcState],
   );
-  const collapsed = useMemo(() => calcState?.collapsed ?? [], [calcState]);
-  const collapsedSet = useMemo(() => new Set(collapsed), [collapsed]);
-  const auto = useMemo(() => calcState?.auto ?? [], [calcState]);
-  const target = useMemo(() => calcState?.target ?? null, [calcState]);
-  const inventory = useMemo(() => calcState?.inventory ?? [], [calcState]);
-  const effectiveSelections = useMemo(
-    () => ({ ...defaults, ...selections }),
-    [defaults, selections],
+
+  const getRecipesForItem = useCallback(
+    (materialId: string, kind: CalcKind): CalcRecipeSummary[] => {
+      if (!catalog) return [];
+      return summarizeRecipes(
+        dataOutMap,
+        dataRecipeMap,
+        catalog.types,
+        summaryCacheFor(dataOutMap, dataRecipeMap),
+        materialId,
+        kind,
+      );
+    },
+    [catalog, dataOutMap, dataRecipeMap],
+  );
+
+  const tagMembers = useCallback(
+    (tagId: string) => dataTagMap.get(tagId),
+    [dataTagMap],
   );
-  const inputKey = useMemo(
+
+  const { nodes, flows } = useMemo(
     () =>
-      JSON.stringify([
-        target,
-        inventory,
-        effectiveSelections,
-        tagSelections,
-        collapsed,
-        auto,
-      ]),
-    [target, inventory, effectiveSelections, tagSelections, collapsed, auto],
+      buildScheme({
+        cards,
+        wires,
+        ctx: {
+          recipeMap: dataRecipeMap,
+          getRecipesForItem,
+          tagMembers,
+          tagSelections,
+          recipesResolved: (id) => dataOutMap.has(id),
+          deadIds: dataDeadIds,
+        },
+      }),
+    [
+      cards,
+      wires,
+      dataRecipeMap,
+      getRecipesForItem,
+      tagMembers,
+      tagSelections,
+      dataOutMap,
+      dataDeadIds,
+    ],
+  );
+
+  const summary = useMemo(() => schemeSummary(nodes), [nodes]);
+
+  const inputKey = useMemo(
+    () => JSON.stringify([cards, wires, tagSelections]),
+    [cards, wires, tagSelections],
   );
 
   const worker = useCalcWorker({
     dataset,
     catalog,
     activeTabId,
-    inputKey,
     applyMaps,
     resetMaps,
   });
-  const workerDriven = worker.state === 'ready';
-  const { getRecipesForItem, goals, dataSettled, summary, ideal } =
-    useCalcDerived({
-      catalog,
-      target,
-      inventory,
-    auto,
-    effectiveSelections,
-    tagSelections,
-    collapsedSet,
-    data,
-    workerDriven,
-    workerGoals: worker.goals,
-    workerSummary: worker.summary,
-    workerSettled: worker.settled,
-  });
-  const settled = dataSettled && !sharePending;
 
   useCalcResolver({
     catalog,
-    dataset,
     inputKey,
-    dataSettled,
-    activeTabId,
-    target,
-    inventory,
-    effectiveSelections,
-    tagSelections,
-    collapsed,
-    collapsedSet,
-    auto,
-    maps,
-    applyMaps,
-    worker,
-  });
-  const fillTree = useFillTree({
-    catalog,
-    dataset,
-    target,
-    inventory,
-    effectiveSelections,
-    tagSelections,
-    collapsed,
-    auto,
-    maps,
-    applyMaps,
+    cards,
+    recipeMap: dataRecipeMap,
     worker,
   });
 
-  const encodeShare = useCallback(
-    (next?: CalculatorState) => {
-      const state = next ?? {
-        target,
-        inventory,
-        selections,
-        tagSelections,
-        collapsed,
-        auto,
-      };
-      const byPath = new Map<string, CalcNode>();
-      const nodeAncestors = new Map<CalcNode, ReadonlySet<string>>();
-      const materials = new Set<string>();
-      const walk = (n: CalcNode, ancestors: Set<string>): void => {
-        if (n.path) {
-          byPath.set(n.path, n);
-          nodeAncestors.set(n, ancestors);
-        }
-        materials.add(n.materialId);
-        const next =
-          n.recipe && n.need > 0
-            ? new Set(ancestors).add(`${n.kind}:${n.materialId}`)
-            : ancestors;
-        for (const child of n.children) walk(child, next);
-      };
-      for (const goal of goals) walk(goal.node, new Set());
-      const pins: Record<string, string> = {};
-      for (const id of materials) {
-        const pin = effectiveSelections[id];
-        if (pin) pins[id] = pin;
+  const dataSettled = useMemo(() => {
+    for (const card of cards) {
+      if (!dataOutMap.has(card.materialId)) return false;
+      if (
+        card.recipeId &&
+        !dataRecipeMap.has(card.recipeId) &&
+        !dataDeadIds.has(card.recipeId)
+      ) {
+        return false;
       }
-      return encodeCalcShare({
-        state,
-        autoRoots: state.auto ?? [],
-        pins,
-        livePaths: new Set(byPath.keys()),
-        derivablePick: (path) => {
-          const node = byPath.get(path);
-          if (!node?.auto || !node.availableRecipes.length) return undefined;
-          return pickAutoRecipe(
-            node,
-            effectiveSelections,
-            nodeAncestors.get(node) ?? new Set(),
-            {
-              recipeMap: dataRecipeMap,
-              getRecipesForItem,
-              recipesResolved: (id) => dataOutMap.has(id),
-              deadIds: dataDeadIds,
-            },
-          ).pick;
-        },
-      });
-    },
-    [
-      goals,
-      target,
-      inventory,
-      selections,
-      tagSelections,
-      collapsed,
-      auto,
-      effectiveSelections,
-      dataRecipeMap,
-      dataOutMap,
-      dataDeadIds,
-      getRecipesForItem,
-    ],
-  );
-
-  const autoUpgraded = useRef<string | null>(null);
-  useEffect(() => {
-    const upgradeKey = `${activeTabId}:${auto.join(',')}`;
-    if (
-      autoUpgraded.current === upgradeKey ||
-      !auto.length ||
-      !settled ||
-      !activeTabId
-    ) {
-      return;
     }
-    autoUpgraded.current = upgradeKey;
-    const tabId = activeTabId;
-    void fillTree(auto).then((picked) => {
+    return true;
+  }, [cards, dataOutMap, dataRecipeMap, dataDeadIds]);
+  const settled = dataSettled && !sharePending;
 
-      updateCalcTab(storageKey, tabId, (tab) => {
-        const current = tab.state;
-        const liveRoot = (path: string) => /^g0(\/|$)/.test(path);
-        const underRoot = (key: string) =>
-          auto.some((root) => key === root || key.startsWith(`${root}/`));
-        return {
-          ...tab,
-          savedAt: Date.now(),
-          state: {
-            target: current.target,
-            inventory: current.inventory,
-            selections: {
-              ...Object.fromEntries(
-                Object.entries(current.selections).filter(
-                  ([key]) => !underRoot(key),
-                ),
-              ),
-              ...picked,
-            },
-            tagSelections: current.tagSelections,
-            collapsed: current.collapsed,
-            auto: [
-              ...new Set([...(current.auto ?? []), ...auto.filter(liveRoot)]),
-            ],
-          },
-        };
-      });
-    });
-  }, [auto, settled, fillTree, storageKey, activeTabId]);
+  const encodeShare = useCallback(
+    () =>
+      encodeCalcState({
+        cards,
+        wires,
+        tagSelections,
+      }),
+    [cards, wires, tagSelections],
+  );
 
   const recipeBody = useCallback(
     (recipeId: string) => bodyMap.get(recipeId),
     [bodyMap],
   );
 
+  const ensureMaterial = useCallback(
+    (materialId: string) => {
+      if (dataOutMap.has(materialId)) return;
+      void worker
+        .call((api) => api.resolve({ materials: [materialId] }))
+        .catch(() => {});
+    },
+    [dataOutMap, worker],
+  );
+
   return {
-    target,
-    inventory,
-    selections,
+    cards,
+    wires,
     tagSelections,
-    collapsed,
-    auto,
     tabs,
     activeTabId,
     history,
@@ -276,14 +186,18 @@ export function useCalcData(session: RecipeSession) {
     removeHistory,
     recipeDefaults: defaults,
     setRecipeDefault,
-    goals,
+    getRecipesForItem,
+    ensureMaterial,
+    tagMembers,
+    nodes,
+    flows,
     summary,
-    ideal,
     persist,
-    fillTree,
     encodeShare,
     recipeBody,
     settled,
     bodiesLoaded: maps.bodyMap.size,
+    workerSettled: worker.settled,
   };
 }
+

package/src/hooks/calc/use-defaults.ts

@@ -1,4 +1,5 @@
 'use client';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 
 import { useCallback, useEffect, useState } from 'react';
 import {
@@ -7,9 +8,9 @@ import {
   writeRecipeDefault,
 } from '@terrafirmagreg-team/recipe/lib/calc/defaults';
 
-export function useRecipeDefaults(dataset: string) {
+export function useRecipeDefaults(dataset: DatasetRef) {
   const [defaultsState, setDefaultsState] = useState<{
-    dataset: string;
+    dataset: DatasetRef;
     map: Record<string, string>;
   }>(() => ({ dataset, map: readRecipeDefaults(dataset) }));
   const defaults =
@@ -36,3 +37,4 @@ export function useRecipeDefaults(dataset: string) {
 
   return { defaults, setRecipeDefault };
 }
+

package/src/hooks/calc/use-far-mode.ts

@@ -34,3 +34,4 @@ export function useCalcFarMode() {
   }, [setStored]);
   return [mode, setMode] as const;
 }
+

package/src/hooks/calc/use-focus.ts

@@ -2,9 +2,9 @@
 
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { onCalcFocusRequest } from '@terrafirmagreg-team/recipe/lib/calc/focus';
-import type { CalculatorTarget } from '@terrafirmagreg-team/recipe/types/calc';
+import type { CalcCard } from '@terrafirmagreg-team/recipe/types/calc';
 
-export function useCalcFocus(target: CalculatorTarget | null) {
+export function useCalcFocus(cards: CalcCard[]) {
   const focusNodeRef = useRef<((materialId: string) => void) | null>(null);
   const onFocusNode = useCallback(
     (materialId: string) => focusNodeRef.current?.(materialId),
@@ -13,18 +13,19 @@ export function useCalcFocus(target: CalculatorTarget | null) {
   const [focusNodeId, setFocusNodeId] = useState<string | null>(null);
   const [pendingFocus, setPendingFocus] = useState<{
     id: string;
-    seen: CalculatorTarget | null;
+    seen: CalcCard[];
   } | null>(null);
 
   useEffect(
-    () => onCalcFocusRequest((id) => setPendingFocus({ id, seen: target })),
-    [target],
+    () => onCalcFocusRequest((id) => setPendingFocus({ id, seen: cards })),
+    [cards],
   );
 
-  if (pendingFocus && pendingFocus.seen !== target) {
-    setFocusNodeId('g0');
+  if (pendingFocus && pendingFocus.seen !== cards) {
+    setFocusNodeId(cards[cards.length - 1]?.id ?? null);
     setPendingFocus(null);
   }
 
   return { focusNodeRef, onFocusNode, focusNodeId, setFocusNodeId };
 }
+

package/src/hooks/calc/use-maps.ts

@@ -73,3 +73,4 @@ export function useCalcMaps() {
     resetMaps,
   };
 }
+

package/src/hooks/calc/use-reset.ts

@@ -12,3 +12,4 @@ export function useCalcReset(activeTabId: string | null) {
   }
   return { resetGen, setResetGen };
 }
+