@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

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

@@ -0,0 +1,40 @@
+'use client';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+
+import { useCallback, useEffect, useState } from 'react';
+import {
+  readRecipeDefaults,
+  subscribeRecipeDefaults,
+  writeRecipeDefault,
+} from '@terrafirmagreg-team/recipe/lib/calc/defaults';
+
+export function useRecipeDefaults(dataset: DatasetRef) {
+  const [defaultsState, setDefaultsState] = useState<{
+    dataset: DatasetRef;
+    map: Record<string, string>;
+  }>(() => ({ dataset, map: readRecipeDefaults(dataset) }));
+  const defaults =
+    defaultsState.dataset === dataset
+      ? defaultsState.map
+      : readRecipeDefaults(dataset);
+  useEffect(
+    () =>
+      subscribeRecipeDefaults(() =>
+        setDefaultsState({ dataset, map: readRecipeDefaults(dataset) }),
+      ),
+    [dataset],
+  );
+
+  const setRecipeDefault = useCallback(
+    (materialId: string, recipeId: string | null) => {
+      setDefaultsState({
+        dataset,
+        map: writeRecipeDefault(dataset, materialId, recipeId),
+      });
+    },
+    [dataset],
+  );
+
+  return { defaults, setRecipeDefault };
+}
+

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

@@ -0,0 +1,37 @@
+'use client';
+
+import {
+  createContext,
+  startTransition,
+  useCallback,
+  useContext,
+} from 'react';
+import {
+  createStoredValue,
+  literalCodec,
+} from '@terrafirmagreg-team/ui/lib/utils/stored-value';
+import type { CalcFarMode } from '@terrafirmagreg-team/recipe/lib/calc/flow';
+
+const FAR_MODES: CalcFarMode[] = ['full', 'preview', 'hidden'];
+const useStoredMode = createStoredValue(
+  'calc:far',
+  literalCodec(FAR_MODES, 'preview'),
+);
+
+const CalcFarContext = createContext<CalcFarMode>('preview');
+
+export const CalcFarProvider = CalcFarContext.Provider;
+
+export function useCalcFar(): CalcFarMode {
+  return useContext(CalcFarContext);
+}
+
+export function useCalcFarMode() {
+  const [mode, setStored] = useStoredMode();
+  const setMode = useCallback((next: CalcFarMode) => {
+
+    startTransition(() => setStored(next));
+  }, [setStored]);
+  return [mode, setMode] as const;
+}
+

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

@@ -0,0 +1,31 @@
+'use client';
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { onCalcFocusRequest } from '@terrafirmagreg-team/recipe/lib/calc/focus';
+import type { CalcCard } from '@terrafirmagreg-team/recipe/types/calc';
+
+export function useCalcFocus(cards: CalcCard[]) {
+  const focusNodeRef = useRef<((materialId: string) => void) | null>(null);
+  const onFocusNode = useCallback(
+    (materialId: string) => focusNodeRef.current?.(materialId),
+    [],
+  );
+  const [focusNodeId, setFocusNodeId] = useState<string | null>(null);
+  const [pendingFocus, setPendingFocus] = useState<{
+    id: string;
+    seen: CalcCard[];
+  } | null>(null);
+
+  useEffect(
+    () => onCalcFocusRequest((id) => setPendingFocus({ id, seen: cards })),
+    [cards],
+  );
+
+  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

@@ -0,0 +1,76 @@
+'use client';
+
+import { startTransition, useCallback, useDeferredValue, useState } from 'react';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import { mergeNew, mergeSet } from '@terrafirmagreg-team/recipe/lib/calc/resolve';
+import type { RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
+import type { CalcRecipe, TagResolution } from '@terrafirmagreg-team/recipe/types/calc';
+
+export type CalcMaps = {
+  recipeMap: Map<string, CalcRecipe>;
+  bodyMap: Map<string, Recipe>;
+  outMap: Map<string, RecipeCompactRow[]>;
+  tagMap: Map<string, TagResolution>;
+  deadIds: ReadonlySet<string>;
+};
+
+export type CalcMapsSlice = Partial<{
+  out: Map<string, RecipeCompactRow[]>;
+  tag: Map<string, TagResolution>;
+  recipes: Map<string, CalcRecipe>;
+  bodies: Map<string, Recipe>;
+  dead: Set<string>;
+}>;
+
+export function useCalcMaps() {
+  const [recipeMap, setRecipeMap] = useState<Map<string, CalcRecipe>>(
+    () => new Map(),
+  );
+  const [bodyMap, setBodyMap] = useState<Map<string, Recipe>>(() => new Map());
+  const [outMap, setOutMap] = useState<Map<string, RecipeCompactRow[]>>(
+    () => new Map(),
+  );
+  const [tagMap, setTagMap] = useState<Map<string, TagResolution>>(
+    () => new Map(),
+  );
+  const [deadIds, setDeadIds] = useState<ReadonlySet<string>>(() => new Set());
+
+  const dataOutMap = useDeferredValue(outMap);
+  const dataRecipeMap = useDeferredValue(recipeMap);
+  const dataTagMap = useDeferredValue(tagMap);
+  const dataDeadIds = useDeferredValue(deadIds);
+
+  const applyMaps = useCallback((src: CalcMapsSlice, extra?: () => void) => {
+    startTransition(() => {
+      if (src.out) setOutMap((prev) => mergeNew(prev, src.out!));
+      if (src.tag) setTagMap((prev) => mergeNew(prev, src.tag!));
+      if (src.recipes) setRecipeMap((prev) => mergeNew(prev, src.recipes!));
+      if (src.bodies) setBodyMap((prev) => mergeNew(prev, src.bodies!));
+      if (src.dead) setDeadIds((prev) => mergeSet(prev, src.dead!));
+      extra?.();
+    });
+  }, []);
+
+  const resetMaps = useCallback(() => {
+    startTransition(() => {
+      setOutMap(new Map());
+      setTagMap(new Map());
+      setRecipeMap(new Map());
+      setBodyMap(new Map());
+      setDeadIds(new Set());
+    });
+  }, []);
+
+  return {
+    maps: { recipeMap, bodyMap, outMap, tagMap, deadIds },
+    data: {
+      outMap: dataOutMap,
+      recipeMap: dataRecipeMap,
+      tagMap: dataTagMap,
+      deadIds: dataDeadIds,
+    },
+    applyMaps,
+    resetMaps,
+  };
+}
+

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

@@ -0,0 +1,15 @@
+'use client';
+
+import { useState } from 'react';
+
+export function useCalcReset(activeTabId: string | null) {
+  const [resetGen, setResetGen] = useState(0);
+
+  const [prevResetTab, setPrevResetTab] = useState(activeTabId);
+  if (prevResetTab !== activeTabId) {
+    setPrevResetTab(activeTabId);
+    setResetGen((gen) => gen + 1);
+  }
+  return { resetGen, setResetGen };
+}
+

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

@@ -0,0 +1,70 @@
+'use client';
+
+import { useAsyncEffect } from '@terrafirmagreg-team/ui/hooks/use-async-value';
+import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
+import type {
+  CalcCard,
+  CalcRecipe,
+} from '@terrafirmagreg-team/recipe/types/calc';
+import type { useCalcWorker } from './use-worker';
+
+type WorkerSlice = ReturnType<typeof useCalcWorker>;
+
+export function useCalcResolver({
+  catalog,
+  inputKey,
+  cards,
+  recipeMap,
+  worker,
+}: {
+  catalog: RecipeCompactIndex | null;
+  inputKey: string;
+  cards: CalcCard[];
+  recipeMap: Map<string, CalcRecipe>;
+  worker: WorkerSlice;
+}) {
+  const {
+    ref: workerRef,
+    state: workerState,
+    generation,
+    call,
+    isResolved,
+    markResolved,
+  } = worker;
+  useAsyncEffect(async () => {
+    if (
+      !catalog ||
+      (!catalog.items.length && !catalog.fluids?.length) ||
+      workerState === 'pending'
+    ) {
+      return;
+    }
+    if (!workerRef.current) return;
+    if (isResolved(inputKey)) return;
+    markResolved(inputKey);
+
+    const materials = new Set<string>();
+    const recipes = new Set<string>();
+    const tags = new Set<string>();
+    for (const card of cards) {
+      materials.add(card.materialId);
+      if (card.recipeId) recipes.add(card.recipeId);
+    }
+    for (const card of cards) {
+      if (!card.recipeId) continue;
+      const recipe = recipeMap.get(card.recipeId);
+      if (!recipe) continue;
+      for (const input of recipe.inputs) {
+        if (input.tagId) tags.add(input.tagId);
+      }
+    }
+    await call((api) =>
+      api.resolve({
+        materials: [...materials],
+        recipes: [...recipes],
+        tags: [...tags],
+      }),
+    ).catch(() => {});
+  }, [catalog, cards, recipeMap, workerState, generation, call, inputKey]);
+}
+

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

@@ -0,0 +1,13 @@
+'use client';
+
+import { createContext, useContext } from 'react';
+import type { RecipeSession } from '@terrafirmagreg-team/recipe/types';
+
+const CalcSessionContext = createContext<RecipeSession | null>(null);
+
+export const CalcSessionProvider = CalcSessionContext.Provider;
+
+export function useCalcSession(): RecipeSession | null {
+  return useContext(CalcSessionContext);
+}
+

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

@@ -0,0 +1,64 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { decodeCalcState } from '@terrafirmagreg-team/recipe/lib/calc/tree';
+import {
+  newCalcEntry,
+  readCalcTabs,
+  writeCalcTabs,
+} from '@terrafirmagreg-team/recipe/lib/calc/storage';
+import { recipeCalcHref } from '@terrafirmagreg-team/recipe/lib/links';
+import { replaceUrlState } from '@terrafirmagreg-team/ui/lib/utils/history';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+
+export function useCalcShare({
+  storageKey,
+  dataset,
+  lang,
+  incoming,
+}: {
+  storageKey: string;
+  dataset: DatasetRef;
+  lang: string;
+  incoming: string;
+}): boolean {
+  const isShareId = incoming.startsWith('s');
+  const [sharedTree, setSharedTree] = useState<string | null>(null);
+  useEffect(() => {
+    if (!isShareId) return;
+    let cancelled = false;
+    const { id: datasetId, version } = dataset;
+    void fetch(
+      `/api/share/recipe/${encodeURIComponent(datasetId)}/${encodeURIComponent(incoming.slice(1))}${version ? `?version=${encodeURIComponent(version)}` : ''}`,
+    )
+      .then((res) => (res.ok ? res.json() : null))
+      .then((body: { tree?: unknown } | null) => {
+        if (!cancelled)
+          setSharedTree(typeof body?.tree === 'string' ? body.tree : '');
+      })
+      .catch(() => {
+        if (!cancelled) setSharedTree('');
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [isShareId, incoming, dataset]);
+  const transport = isShareId ? sharedTree : incoming || null;
+
+  useEffect(() => {
+    if (transport === null) return;
+    const decoded = transport ? decodeCalcState(transport) : null;
+    if (decoded) {
+      const entry = newCalcEntry(decoded);
+      writeCalcTabs(
+        storageKey,
+        [...readCalcTabs(storageKey), entry],
+        entry.id,
+      );
+    }
+    if (incoming) replaceUrlState(recipeCalcHref(dataset, lang));
+  }, [transport, storageKey, dataset, lang, incoming]);
+
+  return isShareId && sharedTree === null;
+}
+

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

@@ -0,0 +1,126 @@
+'use client';
+
+import { useCallback, useSyncExternalStore } from 'react';
+import {
+  newCalcEntry,
+  readCalcActive,
+  resolveCalcActive,
+  readCalcHistory,
+  readCalcStorage,
+  readCalcTabs,
+  removeCalcHistory,
+  subscribeCalcStorage,
+  updateCalcTab,
+  writeCalcActive,
+  writeCalcStorage,
+  writeCalcTabs,
+  type CalcTreeEntry,
+} from '@terrafirmagreg-team/recipe/lib/calc/storage';
+import type { CalculatorState } from '@terrafirmagreg-team/recipe/types/calc';
+
+const EMPTY_TABS: CalcTreeEntry[] = [];
+const EMPTY_CALC: CalculatorState = {
+  cards: [],
+  wires: [],
+  tagSelections: {},
+};
+
+export function useCalcStorage(storageKey: string) {
+  const readSnapshot = useCallback(
+    () => readCalcStorage(storageKey),
+    [storageKey],
+  );
+  const calcState = useSyncExternalStore(
+    subscribeCalcStorage,
+    readSnapshot,
+    () => null,
+  );
+  const tabs = useSyncExternalStore(
+    subscribeCalcStorage,
+    () => readCalcTabs(storageKey),
+    () => EMPTY_TABS,
+  );
+  const activeTabId = useSyncExternalStore(
+    subscribeCalcStorage,
+    () => resolveCalcActive(readCalcTabs(storageKey), readCalcActive(storageKey)),
+    () => null,
+  );
+  const history = useSyncExternalStore(
+    subscribeCalcStorage,
+    () => readCalcHistory(storageKey),
+    () => EMPTY_TABS,
+  );
+
+  const persist = useCallback(
+    (next: CalculatorState) => {
+      writeCalcStorage(storageKey, next);
+    },
+    [storageKey],
+  );
+
+  const openTab = useCallback(
+    (id: string | null) => writeCalcActive(storageKey, id),
+    [storageKey],
+  );
+
+  const openEntry = useCallback(
+    (entry: CalcTreeEntry) => {
+      const list = readCalcTabs(storageKey);
+      const existing = list.find((tab) => tab.id === entry.id);
+      writeCalcTabs(
+        storageKey,
+        existing ? list : [...list, entry],
+        entry.id,
+      );
+    },
+    [storageKey],
+  );
+  const closeTab = useCallback(
+    (id: string) => {
+      const list = readCalcTabs(storageKey).filter((tab) => tab.id !== id);
+      const active =
+        readCalcActive(storageKey) === id ? null : readCalcActive(storageKey);
+      writeCalcTabs(storageKey, list, active);
+    },
+    [storageKey],
+  );
+  const newTab = useCallback(() => {
+    const entry = newCalcEntry({ ...EMPTY_CALC });
+    writeCalcTabs(storageKey, [...readCalcTabs(storageKey), entry], entry.id);
+  }, [storageKey]);
+  const renameTab = useCallback(
+    (id: string, name: string) => {
+      updateCalcTab(storageKey, id, (tab) => ({
+        ...tab,
+        name: name.trim() || undefined,
+      }));
+    },
+    [storageKey],
+  );
+  const setTabIcon = useCallback(
+    (id: string, icon: CalcTreeEntry['icon']) => {
+      updateCalcTab(storageKey, id, (tab) => ({ ...tab, icon }));
+    },
+    [storageKey],
+  );
+  const removeHistory = useCallback(
+    (id: string) => removeCalcHistory(storageKey, id),
+    [storageKey],
+  );
+
+  return {
+    calcState,
+    tabs,
+    activeTabId,
+    history,
+    persist,
+    openTab,
+    openEntry,
+    closeTab,
+    newTab,
+    renameTab,
+    setTabIcon,
+    removeHistory,
+  };
+}
+

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

@@ -0,0 +1,13 @@
+'use client';
+
+import { createContext, useContext } from 'react';
+import type { CalcTier } from '@terrafirmagreg-team/recipe/lib/calc/flow';
+
+const CalcTierContext = createContext<CalcTier>('near');
+
+export const CalcTierProvider = CalcTierContext.Provider;
+
+export function useCalcTier(): CalcTier {
+  return useContext(CalcTierContext);
+}
+

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

@@ -0,0 +1,24 @@
+'use client';
+
+import { startTransition, useCallback } from 'react';
+import {
+  createStoredValue,
+  literalCodec,
+} from '@terrafirmagreg-team/ui/lib/utils/stored-value';
+import type { CalcViewMode } from '@terrafirmagreg-team/recipe/lib/calc/flow';
+
+const MODES: CalcViewMode[] = ['mini', 'normal', 'detailed'];
+const useStoredMode = createStoredValue(
+  'calc:view',
+  literalCodec(MODES, 'normal'),
+);
+
+export function useCalcViewMode() {
+  const [mode, setStored] = useStoredMode();
+  const setMode = useCallback(
+    (next: CalcViewMode) => startTransition(() => setStored(next)),
+    [setStored],
+  );
+  return [mode, setMode] as const;
+}
+