@terrafirmagreg-team/recipe 0.1.0 → 1.2.1

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

@@ -1,258 +0,0 @@
-'use client';
-
-import { useCallback, useMemo } from 'react';
-import {
-  AUTO_NODE_BUDGET,
-  buildGoal,
-  flattenTree,
-  idealBatchMultiplier,
-  mergeAmounts,
-  type BuildContext,
-  type CalcGoal,
-} from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import {
-  pickAutoRecipe,
-  summaryCacheFor,
-  summarizeRecipes,
-} from '@terrafirmagreg-team/recipe/lib/calc/resolve';
-import type { RecipeCompactRow, RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
-import type {
-  CalcKind,
-  CalcMaterial,
-  CalcNode,
-  CalcRecipe,
-  CalcRecipeSummary,
-  CalculatorTarget,
-  TagResolution,
-} from '@terrafirmagreg-team/recipe/types/calc';
-
-export type CalcDataMaps = {
-  outMap: Map<string, RecipeCompactRow[]>;
-  recipeMap: Map<string, CalcRecipe>;
-  tagMap: Map<string, TagResolution>;
-  deadIds: ReadonlySet<string>;
-};
-
-export function useCalcDerived({
-  catalog,
-  target,
-  inventory,
-  auto,
-  effectiveSelections,
-  tagSelections,
-  collapsedSet,
-  data,
-  workerDriven,
-  workerGoals,
-  workerSummary,
-  workerSettled,
-}: {
-  catalog: RecipeCompactIndex | null;
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-  auto: string[];
-  effectiveSelections: Record<string, string>;
-  tagSelections: Record<string, string>;
-  collapsedSet: Set<string>;
-  data: CalcDataMaps;
-  workerDriven: boolean;
-  workerGoals: CalcGoal[] | null;
-  workerSummary: { raw: CalcMaterial[]; catalysts: CalcMaterial[] } | null;
-  workerSettled: boolean;
-}) {
-  const { outMap: dataOutMap, recipeMap: dataRecipeMap } = data;
-  const { tagMap: dataTagMap, deadIds: dataDeadIds } = data;
-
-  const tagMembers = useCallback(
-    (tagId: string): TagResolution | undefined => dataTagMap.get(tagId),
-    [dataTagMap],
-  );
-
-  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 buildCtx = useCallback(
-    (
-      autoRoots: readonly string[] = [],
-      extraSelections?: Record<string, string>,
-      recipePool?: Map<string, CalcRecipe>,
-    ): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => ({
-      recipeMap: recipePool ?? dataRecipeMap,
-      getRecipesForItem,
-      selections: extraSelections ?? effectiveSelections,
-      tagSelections,
-      tagMembers,
-      collapsed: collapsedSet,
-      autoRoots,
-      autoBudget: { left: AUTO_NODE_BUDGET },
-      recipesResolved: (id) => dataOutMap.has(id),
-      deadIds: dataDeadIds,
-    }),
-    [
-      dataRecipeMap,
-      getRecipesForItem,
-      effectiveSelections,
-      tagSelections,
-      tagMembers,
-      collapsedSet,
-      dataOutMap,
-      dataDeadIds,
-    ],
-  );
-
-  const goals = useMemo<CalcGoal[]>(() => {
-
-    if (!target) return [];
-
-    if (workerGoals?.length) return workerGoals;
-    return [buildGoal(target, buildCtx(auto), 'g0', inventory)];
-  }, [workerGoals, target, inventory, buildCtx, auto]);
-
-  const tagIds = useMemo(() => {
-    if (workerDriven) return [] as string[];
-    const ids = new Set<string>();
-    const walk = (n: CalcNode): void => {
-      if (n.tagId) ids.add(n.tagId);
-      if (n.recipe) {
-        for (const input of n.recipe.inputs) {
-          if (input.tagId) ids.add(input.tagId);
-        }
-      }
-      n.children.forEach(walk);
-    };
-    for (const goal of goals) walk(goal.node);
-    return [...ids];
-  }, [goals, workerDriven]);
-
-  const materialIds = useMemo(() => {
-    if (workerDriven) return [] as string[];
-    const ids = new Set<string>();
-    if (target) ids.add(target.id);
-    const walk = (n: CalcNode): void => {
-      ids.add(n.materialId);
-      n.children.forEach(walk);
-    };
-    for (const goal of goals) walk(goal.node);
-    return [...ids];
-  }, [target, goals, workerDriven]);
-
-  const needed = useMemo(() => {
-    const empty = { recipes: [] as string[], outs: [] as string[] };
-    if (workerDriven) return empty;
-    const recipes = new Set<string>();
-    const outs = new Set<string>();
-    const pickCtx = {
-      recipeMap: dataRecipeMap,
-      getRecipesForItem,
-      recipesResolved: (id: string) => dataOutMap.has(id),
-      deadIds: dataDeadIds,
-    };
-    for (const id of Object.values(effectiveSelections)) {
-      if (id) recipes.add(id);
-    }
-    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.recipe && n.auto && n.availableRecipes.length) {
-        const autoPick = pickAutoRecipe(
-          n,
-          effectiveSelections,
-          ancestors,
-          pickCtx,
-        );
-        if (autoPick.pick) recipes.add(autoPick.pick);
-        for (const id of autoPick.wantRecipes) recipes.add(id);
-        for (const id of autoPick.wantOut) outs.add(id);
-      }
-      for (const child of n.children) walk(child, next);
-    };
-    for (const goal of goals) walk(goal.node, new Set());
-    return { recipes: [...recipes], outs: [...outs] };
-  }, [
-    effectiveSelections,
-    goals,
-    dataDeadIds,
-    workerDriven,
-    dataRecipeMap,
-    dataOutMap,
-    getRecipesForItem,
-  ]);
-
-  const dataSettled = useMemo(
-    () =>
-      workerDriven
-        ? workerSettled
-        : materialIds.every((id) => dataOutMap.has(id)) &&
-          tagIds.every((id) => dataTagMap.has(id)) &&
-          needed.recipes.every(
-            (id) => dataRecipeMap.has(id) || dataDeadIds.has(id),
-          ) &&
-          needed.outs.every((id) => dataOutMap.has(id)),
-    [
-      workerDriven,
-      workerSettled,
-      materialIds,
-      dataOutMap,
-      tagIds,
-      dataTagMap,
-      needed,
-      dataRecipeMap,
-      dataDeadIds,
-    ],
-  );
-
-  const summary = useMemo(() => {
-    const remainders: CalcMaterial[] = [];
-    for (const goal of goals) remainders.push(...goal.remainders);
-    if (workerSummary) {
-      return {
-        raw: workerSummary.raw,
-        remainders: mergeAmounts(remainders),
-        catalysts: workerSummary.catalysts,
-      };
-    }
-    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),
-      remainders: mergeAmounts(remainders),
-      catalysts: mergeAmounts(catalysts),
-    };
-  }, [goals, workerSummary]);
-
-  const ideal = useMemo(() => {
-    const root = goals[0]?.node;
-    if (!root) return 1;
-    const mult = idealBatchMultiplier(root);
-    return Number.isFinite(mult) ? mult : Infinity;
-  }, [goals]);
-
-  return {
-    tagMembers,
-    getRecipesForItem,
-    buildCtx,
-    goals,
-    dataSettled,
-    summary,
-    ideal,
-  };
-}

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

@@ -1,23 +0,0 @@
-'use client';
-
-import { startTransition, useCallback } from 'react';
-import {
-  createStoredValue,
-  literalCodec,
-} from '@terrafirmagreg-team/ui/lib/utils/stored-value';
-import type { CalcDirection } from '@terrafirmagreg-team/recipe/lib/calc/flow';
-
-const DIRS: CalcDirection[] = ['vertical', 'horizontal'];
-const useStoredDir = createStoredValue(
-  'calc:dir',
-  literalCodec(DIRS, 'vertical'),
-);
-
-export function useCalcDirection() {
-  const [dir, setStored] = useStoredDir();
-  const setDir = useCallback(
-    (next: CalcDirection) => startTransition(() => setStored(next)),
-    [setStored],
-  );
-  return [dir, setDir] as const;
-}

package/src/hooks/calc/use-edge-style.ts

@@ -1,40 +0,0 @@
-'use client';
-
-import { startTransition, useCallback } from 'react';
-import {
-  createStoredValue,
-  type StoredCodec,
-} from '@terrafirmagreg-team/ui/lib/utils/stored-value';
-import type { CalcEdgeStyle } from '@terrafirmagreg-team/recipe/lib/calc/flow';
-
-const STYLES: CalcEdgeStyle[] = [
-  'default',
-  'straight',
-  'step',
-  'smoothstep',
-  'circuit',
-];
-
-const MIGRATED: Record<string, CalcEdgeStyle> = {
-  corner: 'step',
-  route: 'circuit',
-};
-const codec: StoredCodec<CalcEdgeStyle> = {
-  read: (raw) =>
-    raw == null
-      ? 'default'
-      : STYLES.includes(raw as CalcEdgeStyle)
-        ? (raw as CalcEdgeStyle)
-        : (MIGRATED[raw] ?? 'default'),
-  write: (value) => value,
-};
-const useStoredStyle = createStoredValue('calc:edge', codec);
-
-export function useCalcEdgeStyle() {
-  const [style, setStored] = useStoredStyle();
-  const setStyle = useCallback((next: CalcEdgeStyle) => {
-
-    startTransition(() => setStored(next));
-  }, [setStored]);
-  return [style, setStyle] as const;
-}

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

@@ -1,213 +0,0 @@
-'use client';
-
-import { useCallback } from 'react';
-import {
-  AUTO_NODE_BUDGET,
-  buildGoal,
-  type BuildContext,
-  type CalcGoal,
-} from '@terrafirmagreg-team/recipe/lib/calc/tree';
-import {
-  createFrameBudget,
-  createSummaries,
-  fetchSlices,
-  pickAutoRecipe,
-} from '@terrafirmagreg-team/recipe/lib/calc/resolve';
-import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
-import type {
-  CalcMaterial,
-  CalcNode,
-  CalculatorTarget,
-} from '@terrafirmagreg-team/recipe/types/calc';
-import type { CalcMaps, CalcMapsSlice } from './use-maps';
-import type { useCalcWorker } from './use-worker';
-
-type WorkerSlice = ReturnType<typeof useCalcWorker>;
-
-export function useFillTree({
-  catalog,
-  dataset,
-  target,
-  inventory,
-  effectiveSelections,
-  tagSelections,
-  collapsed,
-  auto,
-  maps,
-  applyMaps,
-  worker,
-}: {
-  catalog: RecipeCompactIndex | null;
-  dataset: string;
-  target: CalculatorTarget | null;
-  inventory: CalcMaterial[];
-  effectiveSelections: Record<string, string>;
-  tagSelections: Record<string, string>;
-  collapsed: string[];
-  auto: string[];
-  maps: CalcMaps;
-  applyMaps: (src: CalcMapsSlice) => void;
-  worker: Pick<WorkerSlice, 'ref' | 'call'>;
-}) {
-  const { recipeMap, bodyMap, outMap, tagMap, deadIds } = maps;
-  const { ref: workerRef, call } = worker;
-  return useCallback(
-    async (roots: readonly string[]) => {
-      const picks: Record<string, string> = {};
-      if (!catalog) return picks;
-      if (workerRef.current) {
-        return (
-          (await call((api) =>
-              api.fill({
-                roots: [...roots],
-                target,
-                inventory,
-                selections: effectiveSelections,
-                tagSelections,
-                collapsed,
-                auto,
-              }),
-            ).catch(() => null)) ?? picks
-        );
-      }
-      const localRecipes = new Map(recipeMap);
-      const localOut = new Map(outMap);
-      const localTag = new Map(tagMap);
-      const localBodies = new Map(bodyMap);
-      const openCollapsed = new Set<string>();
-      const deadLocal = new Set(deadIds);
-      const summaries = createSummaries(catalog, localOut, localRecipes);
-      const yieldToInput = createFrameBudget();
-      let latestGoals: CalcGoal[] = [];
-      for (let iter = 0; iter < 200 && roots.length; iter += 1) {
-        await yieldToInput();
-        const merged = { ...effectiveSelections, ...picks };
-        const ctxAuto = (
-          budget: number,
-        ): Omit<BuildContext, 'pool' | 'used' | 'usedMaterials'> => ({
-          recipeMap: localRecipes,
-          getRecipesForItem: summaries.get,
-          selections: merged,
-          tagSelections,
-          tagMembers: (id) => localTag.get(id),
-          collapsed: openCollapsed,
-          autoRoots: roots,
-          autoBudget: { left: budget },
-          recipesResolved: (id) => localOut.has(id),
-          deadIds: deadLocal,
-        });
-        const wanted = new Set<string>();
-        const wantedOut = new Set<string>();
-        const wantedTag = new Set<string>();
-        const built: CalcGoal[] = [];
-        if (target) {
-          const goalCtx = ctxAuto(AUTO_NODE_BUDGET);
-          const goal = buildGoal(target, goalCtx, 'g0', 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.path) {
-              if (n.recipe) picks[n.path] = n.recipe.recipeId;
-              else if (n.auto && !n.catalyst && n.availableRecipes.length) {
-                const autoPick = pickAutoRecipe(
-                  n,
-                  merged,
-                  ancestors,
-                  goalCtx,
-                );
-                if (
-                  autoPick.pick &&
-                  !localRecipes.has(autoPick.pick) &&
-                  !deadLocal.has(autoPick.pick)
-                )
-                  wanted.add(autoPick.pick);
-                for (const id of autoPick.wantRecipes) {
-                  if (!localRecipes.has(id) && !deadLocal.has(id))
-                    wanted.add(id);
-                }
-                for (const id of autoPick.wantOut) {
-                  if (!localOut.has(id)) wantedOut.add(id);
-                }
-              }
-            }
-            if (n.tagId && !localTag.has(n.tagId)) {
-              wantedTag.add(n.tagId);
-            } else if (!localOut.has(n.materialId)) {
-              wantedOut.add(n.materialId);
-            }
-            for (const child of n.children) walk(child, next);
-          };
-          walk(goal.node, new Set());
-        }
-        latestGoals = built;
-        if (!wanted.size && !wantedOut.size && !wantedTag.size) break;
-        const slices = await fetchSlices(dataset, catalog, {
-          recipes: wanted,
-          outs: wantedOut,
-          tags: wantedTag,
-        });
-        let progressed = false;
-        for (const [id, entry] of slices.recipes) {
-          localRecipes.set(id, entry.calc);
-          localBodies.set(id, entry.body);
-          progressed = true;
-        }
-        for (const id of slices.dead) deadLocal.add(id);
-        for (const [id, list] of slices.outs) {
-          localOut.set(id, list);
-          progressed = true;
-        }
-        for (const [id, tag] of slices.tags) {
-          localTag.set(id, tag);
-          progressed = true;
-        }
-        if (!progressed) break;
-        summaries.clear();
-      }
-      applyMaps({
-        out: localOut,
-        tag: localTag,
-        recipes: localRecipes,
-        bodies: localBodies,
-        dead: deadLocal,
-      });
-
-      const out: Record<string, string> = {};
-      const collect = (n: CalcNode): void => {
-        if (
-          n.path &&
-          n.recipe &&
-          roots.some(
-            (root) => n.path === root || n.path!.startsWith(`${root}/`),
-          )
-        ) {
-          out[n.path] = n.recipe.recipeId;
-        }
-        for (const child of n.children) collect(child);
-      };
-      for (const goal of latestGoals) collect(goal.node);
-      return out;
-    },
-    [
-      recipeMap,
-      bodyMap,
-      outMap,
-      tagMap,
-      deadIds,
-      effectiveSelections,
-      tagSelections,
-      target,
-      inventory,
-      dataset,
-      catalog,
-      collapsed,
-      auto,
-      call,
-      workerRef,
-      applyMaps,
-    ],
-  );
-}