@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/data/slot-io.ts

@@ -0,0 +1,44 @@
+import type { DumpRecipeLayout } from '@terrafirmagreg-team/recipe/lib/data/category/dto';
+import type { RecipeSlotType } from '@terrafirmagreg-team/recipe/lib/data/dto';
+
+export function outputBoundary(
+  slots: Readonly<
+    Record<string, { type?: unknown; x?: unknown } | undefined>
+  >,
+  layout?: DumpRecipeLayout,
+): number {
+  const byId = layout
+    ? new Map(layout.slots.map((slot) => [slot.id, slot]))
+    : undefined;
+  let bound = Number.POSITIVE_INFINITY;
+  for (const [id, slot] of Object.entries(slots)) {
+    if (slot?.type !== 'output') continue;
+    const x = typeof slot.x === 'number' ? slot.x : byId?.get(id)?.x;
+    if (typeof x === 'number') bound = Math.min(bound, x);
+  }
+  if (!Number.isFinite(bound) && byId) {
+    for (const slot of byId.values()) {
+      if (slot.role === 'output' && typeof slot.x === 'number') {
+        bound = Math.min(bound, slot.x);
+      }
+    }
+  }
+  if (!Number.isFinite(bound)) {
+    bound = layout?.w ? layout.w / 2 : Number.POSITIVE_INFINITY;
+  }
+  return bound;
+}
+
+export function slotIoRole(
+  type: RecipeSlotType,
+  x: number | undefined,
+  boundary: number,
+): 'input' | 'output' | 'catalyst' {
+  if (type === 'output') return 'output';
+  if (type === 'catalyst') return 'catalyst';
+  if (type === 'tank') {
+    return typeof x === 'number' && x >= boundary ? 'output' : 'input';
+  }
+  return 'input';
+}
+

package/src/lib/dump.ts

@@ -0,0 +1,6 @@
+export function recipeDumpHasContent(dump: {
+  mods: readonly { recipeIndex: string | null }[];
+}): boolean {
+  return dump.mods.some((mod) => mod.recipeIndex != null);
+}
+

package/src/lib/embed.ts

@@ -0,0 +1,22 @@
+import { RecipeEmbedCard } from '@terrafirmagreg-team/recipe/components/embed-card';
+import { loadClientRecipe } from '@terrafirmagreg-team/recipe/lib/client/recipe';
+import {
+  recipeCardImageUrl,
+  recipeHref,
+} from '@terrafirmagreg-team/recipe/lib/links';
+import { recipeTitle } from '@terrafirmagreg-team/recipe/lib/data/parse';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type {
+  EmbedRecipe,
+  SectionEmbeds,
+} from '@terrafirmagreg-team/kit/types/embeds';
+
+export const recipeSectionEmbed: NonNullable<SectionEmbeds['recipe']> = {
+  href: (dataset, lang, ref) => recipeHref(dataset, lang, { id: ref.id }),
+  cardImageUrl: recipeCardImageUrl,
+  load: async (dataset, id) =>
+    (await loadClientRecipe(dataset, id)) as EmbedRecipe | undefined,
+  title: (recipe, langMap) =>
+    recipeTitle(recipe as unknown as Recipe, langMap),
+  Card: RecipeEmbedCard,
+};

package/src/lib/favorite-hover.ts

@@ -0,0 +1,13 @@
+export type FavoriteHoverTarget =
+  | { kind: 'stack'; id: string; ref?: 'item' | 'fluid' }
+  | { kind: 'recipe'; id: string; type: string; icon?: string };
+
+export const favoriteHover: {
+  base?: FavoriteHoverTarget;
+  slot?: FavoriteHoverTarget;
+} = {};
+
+export function favoriteHoverTarget(): FavoriteHoverTarget | undefined {
+  return favoriteHover.slot ?? favoriteHover.base;
+}
+

package/src/lib/fluid-outputs.ts

@@ -0,0 +1,70 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
+import { outputBoundary } from '@terrafirmagreg-team/recipe/lib/data/slot-io';
+import { loadTypeRows } from '@terrafirmagreg-team/recipe/lib/client-index';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+export type FluidIoIndex = {
+  inputs: Map<string, string[]>;
+  outputs: Map<string, string[]>;
+};
+
+const cache = createDatasetCache(
+  build,
+  (dataset) => `${dataset.id}/${dataset.version ?? ''}`,
+);
+
+function tankCategories(index: RecipeCompactIndex, role: 'input' | 'output') {
+  return (index.categories ?? []).filter((cat) => {
+    const layout = cat.layout;
+    if (!layout) return false;
+    const bound = outputBoundary({}, layout);
+    return layout.slots.some((slot) =>
+      slot.role === 'tank' &&
+      (role === 'output' ? slot.x >= bound : slot.x < bound),
+    );
+  });
+}
+
+async function build(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+): Promise<FluidIoIndex> {
+  const fluids = new Set(index.fluids ?? []);
+  const inputs = new Map<string, string[]>();
+  const outputs = new Map<string, string[]>();
+  const typeIds = new Set([
+    ...tankCategories(index, 'input').map((cat) => cat.id),
+    ...tankCategories(index, 'output').map((cat) => cat.id),
+  ]);
+  const perType = await Promise.all(
+    [...typeIds].map((typeId) =>
+      loadTypeRows(dataset, index, typeId).catch(() => []),
+    ),
+  );
+  for (const rows of perType) {
+    for (const row of rows) {
+      for (const id of row.in) {
+        if (!fluids.has(id)) continue;
+        const list = inputs.get(id);
+        if (list) list.push(row.id);
+        else inputs.set(id, [row.id]);
+      }
+      for (const id of row.out) {
+        if (!fluids.has(id)) continue;
+        const list = outputs.get(id);
+        if (list) list.push(row.id);
+        else outputs.set(id, [row.id]);
+      }
+    }
+  }
+  return { inputs, outputs };
+}
+
+export function loadFluidIoIndex(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+): Promise<FluidIoIndex> {
+  return cache(dataset, index);
+}
+

package/src/lib/forge/actions.ts

@@ -0,0 +1,59 @@
+import { langString } from '@terrafirmagreg-team/dump/lib/dump/assets/lang/names';
+import type { ForgeRule, ForgeRuleAction } from '@terrafirmagreg-team/recipe/types/forge';
+
+const FORGE_STEP_LANG_PREFIX = 'tfc.enum.forgestep.';
+const HIT_VARIANTS = new Set(['light', 'medium', 'hard']);
+
+export function forgeActionLabel(
+  langMap: Record<string, string>,
+  id: string,
+): string {
+  const key = HIT_VARIANTS.has(id) ? `hit_${id}` : id;
+  return langString(langMap, `${FORGE_STEP_LANG_PREFIX}${key}`) ?? id;
+}
+
+export const FORGE_ACTIONS = [
+  { id: 'light', action: 'hit', delta: -3 },
+  { id: 'medium', action: 'hit', delta: -6 },
+  { id: 'hard', action: 'hit', delta: -9 },
+  { id: 'draw', action: 'draw', delta: -15 },
+  { id: 'punch', action: 'punch', delta: 2 },
+  { id: 'bend', action: 'bend', delta: 7 },
+  { id: 'upset', action: 'upset', delta: 13 },
+  { id: 'shrink', action: 'shrink', delta: 16 },
+] as const satisfies readonly {
+  id: string;
+  action: ForgeRuleAction;
+  delta: number;
+}[];
+
+export function cleanForgeText(text: string): string {
+  return text.replace(/§./g, '').trim();
+}
+
+export function parseForgeRuleTooltip(text: string): ForgeRule | undefined {
+  const match =
+    /^(Hit|Draw|Punch|Bend|Upset|Shrink) (Last|Second Last|Third Last|Not Last|Any)$/i.exec(
+      cleanForgeText(text),
+    );
+  if (!match) return undefined;
+  return {
+    action: match[1].toLowerCase() as ForgeRule['action'],
+    order: match[2].toLowerCase().replaceAll(' ', '_') as ForgeRule['order'],
+  };
+}
+
+export function forgeRulesMatch(
+  rules: readonly ForgeRule[],
+  last: readonly (ForgeRuleAction | '')[],
+): boolean {
+  return rules.every(({ action, order }) => {
+    if (order === 'last') return last[0] === action;
+    if (order === 'second_last') return last[1] === action;
+    if (order === 'third_last') return last[2] === action;
+    return (order === 'not_last' ? last.slice(1, 3) : last.slice(0, 3)).includes(
+      action,
+    );
+  });
+}
+

package/src/lib/forge/data.ts

@@ -0,0 +1,51 @@
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type { ForgeRecipe } from '@terrafirmagreg-team/recipe/types/forge';
+import { stackIdFromRef } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { parseForgeRuleTooltip } from './actions';
+
+export function toForgeRecipe(recipe: Recipe): ForgeRecipe {
+  const tooltips = recipe.widgets.flatMap((widget) =>
+    'tooltip' in widget ? (widget.tooltip ?? []) : [],
+  );
+  const parsed = tooltips.map(parseForgeRuleTooltip);
+  return {
+    recipe,
+    rules: parsed.filter((rule) => rule !== undefined),
+    rulesSupported:
+      tooltips.length > 0 && parsed.every((rule) => rule !== undefined),
+  };
+}
+
+const ANVIL_TIER_ORDER = [
+  'rock',
+  'stone',
+  'copper',
+  'bronze',
+  'wrought_iron',
+  'steel',
+  'black_steel',
+  'red_or_blue',
+];
+
+export function anvilGroup(recipe: Recipe): { id: string; icon?: string } {
+  const catalyst = Object.values(recipe.slots).find(
+    (slot) => slot.type === 'catalyst',
+  );
+  const ref = catalyst?.ref;
+  if (!ref) return { id: '' };
+  const id = ref.kind === 'itemTag' ? `#${ref.id}` : stackIdFromRef(ref);
+  return { id, icon: catalyst?.alternatives?.[0]?.id ?? ref.id };
+}
+
+export function anvilGroupRank(groupId: string): number {
+  const last = groupId
+    .replace(/^#/, '')
+    .split('/')
+    .pop()!
+    .split(':')
+    .pop()!
+    .replace(/_anvils?$/, '');
+  const index = ANVIL_TIER_ORDER.indexOf(last);
+  return index < 0 ? ANVIL_TIER_ORDER.length : index;
+}
+

package/src/lib/forge/solve.ts

@@ -0,0 +1,80 @@
+import type { ForgeRule, ForgeRuleAction } from '@terrafirmagreg-team/recipe/types/forge';
+import { FORGE_ACTIONS, forgeRulesMatch } from './actions';
+
+const KINDS: (ForgeRuleAction | '')[] = [
+  '',
+  'hit',
+  'draw',
+  'punch',
+  'bend',
+  'upset',
+  'shrink',
+];
+const HISTORIES = 343;
+const STATES = 150 * HISTORIES;
+
+export function solveForgeSteps(
+  start: { work: number; last: readonly ForgeRuleAction[] },
+  target: number,
+  rules: readonly ForgeRule[],
+): number[] | null {
+  if (
+    !Number.isInteger(target) ||
+    target < 0 ||
+    target >= 150 ||
+    !Number.isInteger(start.work) ||
+    start.work < 0 ||
+    start.work >= 150
+  ) {
+    return null;
+  }
+  const last = [...start.last.slice(0, 3)].reverse();
+  while (last.length < 3) last.push('' as ForgeRuleAction);
+  const startHistory =
+    KINDS.indexOf(last[0]) +
+    KINDS.indexOf(last[1]) * 7 +
+    KINDS.indexOf(last[2]) * 49;
+  const parent = new Int32Array(STATES).fill(-1);
+  const via = new Uint8Array(STATES);
+  const queue = new Int32Array(STATES);
+  const startState = start.work * HISTORIES + startHistory;
+  queue[0] = startState;
+  parent[startState] = startState;
+  let end = 1;
+  for (let head = 0; head < end; head++) {
+    const state = queue[head];
+    const work = Math.floor(state / HISTORIES);
+    const history = state % HISTORIES;
+    if (
+      work === target &&
+      forgeRulesMatch(rules, [
+        KINDS[history % 7],
+        KINDS[Math.floor(history / 7) % 7],
+        KINDS[Math.floor(history / 49)],
+      ])
+    ) {
+      const steps: number[] = [];
+      for (
+        let cursor = state;
+        cursor !== startState;
+        cursor = parent[cursor]
+      ) {
+        steps.push(via[cursor]);
+      }
+      return steps.reverse();
+    }
+    for (let i = 0; i < FORGE_ACTIONS.length; i++) {
+      const action = FORGE_ACTIONS[i];
+      const nextWork = work + action.delta;
+      if (nextWork < 0 || nextWork >= 150) continue;
+      const nextHistory = KINDS.indexOf(action.action) + (history % 49) * 7;
+      const next = nextWork * HISTORIES + nextHistory;
+      if (parent[next] !== -1) continue;
+      parent[next] = state;
+      via[next] = i;
+      queue[end++] = next;
+    }
+  }
+  return null;
+}
+

package/src/lib/group.ts

@@ -0,0 +1,23 @@
+import type {
+  CategoryGroup,
+  RecipeCategory,
+  RecipeCompactRow,
+} from '@terrafirmagreg-team/recipe/types';
+
+export function groupByCategory(
+  rows: RecipeCompactRow[],
+  types: string[],
+  categories?: RecipeCategory[],
+): CategoryGroup[] {
+  const groups = [...Map.groupBy(rows, (row) => types[row.type] ?? '')].map(
+    ([category, rows]) => ({ category, rows }),
+  );
+  if (!categories?.length) return groups;
+  const order = new Map(categories.map((row, index) => [row.id, index]));
+  return groups.sort(
+    (a, b) =>
+      (order.get(a.category) ?? Number.MAX_SAFE_INTEGER) -
+      (order.get(b.category) ?? Number.MAX_SAFE_INTEGER),
+  );
+}
+

package/src/lib/index-store.ts

@@ -0,0 +1,70 @@
+'use client';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+
+import { useSyncExternalStore } from 'react';
+import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
+
+const indexes = new Map<string, RecipeCompactIndex>();
+const listeners = new Set<() => void>();
+
+function refKey(dataset: DatasetRef) {
+  return `${dataset.id}/${dataset.version ?? ''}`;
+}
+
+function key(dataset: DatasetRef, lang: string) {
+  return `${refKey(dataset)} ${lang}`;
+}
+
+const namesSnapshots = new Map<
+  string,
+  Record<string, Record<string, string>>
+>();
+
+function rebuildNames(dataset: DatasetRef) {
+  const merged: Record<string, Record<string, string>> = {};
+  for (const [k, index] of indexes) {
+    if (!k.startsWith(`${refKey(dataset)} `)) continue;
+    for (const [lang, names] of Object.entries(index.names ?? {})) {
+      merged[lang] = { ...merged[lang], ...names };
+    }
+  }
+  namesSnapshots.set(refKey(dataset), merged);
+}
+
+export function publishRecipeIndex(
+  dataset: DatasetRef,
+  lang: string,
+  index: RecipeCompactIndex,
+) {
+  if (indexes.get(key(dataset, lang)) === index) return;
+  indexes.set(key(dataset, lang), index);
+  rebuildNames(dataset);
+  for (const listener of listeners) listener();
+}
+
+function subscribe(listener: () => void) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function useRecipeIndexStore(
+  dataset: DatasetRef,
+  lang: string,
+): RecipeCompactIndex | null {
+  return useSyncExternalStore(
+    subscribe,
+    () => indexes.get(key(dataset, lang)) ?? null,
+    () => null,
+  );
+}
+
+export function useRecipeIndexNames(
+  dataset: DatasetRef,
+): Record<string, Record<string, string>> | null {
+  return useSyncExternalStore(
+    subscribe,
+    () => namesSnapshots.get(refKey(dataset)) ?? null,
+    () => null,
+  );
+}
+

package/src/lib/links.ts

@@ -0,0 +1,131 @@
+import { encodeQueryValue, withLang } from '@terrafirmagreg-team/translate/lib/url';
+import type { Lang } from '@terrafirmagreg-team/translate/types/locale';
+import {
+  type DatasetRef,
+  sectionUrl,
+} from '@terrafirmagreg-team/sites/location';
+import { dumpRelPublicUrl, splitDumpId, tagPseudoId } from '@terrafirmagreg-team/dump/lib/dump/paths';
+import type { RecipeHrefOpts, RecipePlace } from '@terrafirmagreg-team/recipe/types';
+
+export type { RecipeHrefOpts, RecipePlace } from '@terrafirmagreg-team/recipe/types';
+
+function recipeQuery(
+  entries: Array<readonly [string, string | number | undefined]>,
+): string {
+  const parts: string[] = [];
+  for (const [key, value] of entries) {
+    if (value === undefined || value === '') continue;
+    parts.push(`${key}=${encodeQueryValue(String(value))}`);
+  }
+  return parts.join('&');
+}
+
+export function recipeBasePath(dataset: DatasetRef): string {
+  return sectionUrl('recipe', dataset.id);
+}
+
+export const RECIPE_ALL_TYPE = 'all';
+
+export function recipePlaceFromParams(params: {
+  get(name: string): string | null;
+}): RecipePlace {
+  const tool = params.get('tool');
+  if (tool === 'calc' || tool === 'forge' || tool === 'alloy') {
+    return { kind: tool };
+  }
+  const type = params.get('type');
+  return { kind: 'type', id: type || RECIPE_ALL_TYPE };
+}
+
+export function recipePlaceOpts(
+  place: RecipePlace | undefined,
+): Pick<RecipeHrefOpts, 'type' | 'tool'> {
+  if (place?.kind === 'type') {
+    return place.id === RECIPE_ALL_TYPE ? {} : { type: place.id };
+  }
+  return place ? { tool: place.kind } : {};
+}
+
+export function recipeHref(
+  dataset: DatasetRef,
+  lang: Lang | undefined,
+  opts?: RecipeHrefOpts,
+): string {
+  const query = recipeQuery([
+    ['type', opts?.type],
+    ['tool', opts?.tool],
+    ['item', opts?.item],
+    ['fluid', opts?.item ? undefined : opts?.fluid],
+    ['id', opts?.id],
+    ['solo', opts?.id ? opts?.solo : undefined],
+    ['relation', opts?.relation],
+    ['unit', opts?.tool === 'alloy' ? opts?.unit : undefined],
+    ['mix', opts?.tool === 'alloy' ? opts?.mix : undefined],
+    ['tab', opts?.tab],
+    ['search', opts?.search],
+    [
+      'rpage',
+      opts?.rpage && opts.rpage > 1 ? Math.floor(opts.rpage) : undefined,
+    ],
+    ['version', dataset.version],
+  ]);
+  const base = recipeBasePath(dataset);
+  const href = query ? `${base}?${query}` : base;
+  return lang ? withLang(href, lang) : href;
+}
+
+export function recipeCalcHref(
+  dataset: DatasetRef,
+  lang: Lang | undefined,
+  tree?: string,
+): string {
+  const query = recipeQuery([
+    ['tool', 'calc'],
+    ['tree', tree],
+    ['version', dataset.version],
+  ]);
+  const href = `${recipeBasePath(dataset)}?${query}`;
+  return lang ? withLang(href, lang) : href;
+}
+
+export function recipeStackHref(
+  dataset: DatasetRef,
+  lang: Lang,
+  id: string,
+  opts?: Pick<RecipeHrefOpts, 'tab' | 'search'> & {
+    kind?: 'item' | 'fluid' | 'tag';
+    tagKind?: string;
+  },
+): string {
+  const kept = {
+    tab: opts?.tab,
+    search: opts?.search,
+  };
+  if (opts?.kind === 'tag' || id.startsWith('#')) {
+    const bare = id.startsWith('#') ? id.slice(1) : id;
+    const tagKind = opts?.tagKind ?? 'item';
+    return recipeHref(dataset, lang, {
+      type: 'emi:tag',
+      id: tagPseudoId(bare, tagKind),
+      ...kept,
+    });
+  }
+  return opts?.kind === 'fluid'
+    ? recipeHref(dataset, lang, { fluid: id, ...kept })
+    : recipeHref(dataset, lang, { item: id, ...kept });
+}
+
+export { recipeImageUrl } from '@terrafirmagreg-team/dump/lib/dump/assets/urls';
+
+export function recipeCardImageUrl(
+  dataset: DatasetRef,
+  recipeId: string | undefined,
+): string | undefined {
+  const parts = recipeId ? splitDumpId(recipeId) : undefined;
+  if (!parts) return undefined;
+  return dumpRelPublicUrl(
+    dataset,
+    `assets/${parts.ns}/textures/recipe/${parts.path}.webp`,
+  );
+}
+