@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/lookup.ts

@@ -0,0 +1,119 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { asStringList } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import type { RecipeCompactIndex, RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
+import { registryId, splitDumpId } from '@terrafirmagreg-team/dump/lib/dump/paths';
+import { resolveClientTag } from '@terrafirmagreg-team/dump/lib/dump/client/tags';
+import {
+  loadRegistryEntrySlice,
+  loadTagSlice,
+  loadTypeRows,
+  resolveRecipeRows,
+} from '@terrafirmagreg-team/recipe/lib/client-index';
+import { stackIdFromRef } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { loadFluidIoIndex } from '@terrafirmagreg-team/recipe/lib/fluid-outputs';
+
+export { registryId, tagPseudoId } from '@terrafirmagreg-team/dump/lib/dump/paths';
+
+function uniqueRows(rows: RecipeCompactRow[]): RecipeCompactRow[] {
+  const seen = new Set<string>();
+  return rows.filter((row) => {
+    if (seen.has(row.id)) return false;
+    seen.add(row.id);
+    return true;
+  });
+}
+
+const ALL_KINDS = ['item', 'block', 'fluid', 'entity'];
+
+async function entryEdges(
+  dataset: DatasetRef,
+  kinds: string[],
+  id: string,
+  field: 'usedBy' | 'producedBy',
+): Promise<string[]> {
+  const edges = await Promise.all(
+    kinds.map((kind) =>
+      loadRegistryEntrySlice(dataset, kind, id).then((entry) =>
+        asStringList(entry?.[field]),
+      ),
+    ),
+  );
+  return [...new Set(edges.flat())];
+}
+
+export async function recipesForOutput(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+  item: string,
+  opts?: { includeTagRows?: boolean },
+): Promise<RecipeCompactRow[]> {
+  const base = registryId(item);
+  const [refs, io] = await Promise.all([
+    entryEdges(dataset, ALL_KINDS, base, 'producedBy'),
+    index.fluids?.includes(base)
+      ? loadFluidIoIndex(dataset, index).catch(() => undefined)
+      : undefined,
+  ]);
+  const extra = io?.outputs.get(base) ?? [];
+  const ids = extra.length ? [...new Set([...refs, ...extra])] : refs;
+  return resolveRecipeRows(dataset, index, ids, opts);
+}
+
+export async function usesForInput(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+  item: string,
+  kind: string = 'item',
+  opts?: { includeTagRows?: boolean },
+): Promise<RecipeCompactRow[]> {
+  const base = registryId(item);
+  const ns = splitDumpId(base)?.ns;
+  if (!ns) return [];
+  const tagKinds = [...new Set(kind === 'item' ? ['item', 'block'] : [kind])];
+  const stationTypes = (index.categories ?? [])
+    .filter((cat) =>
+      (cat.workstations ?? []).some(
+        (ref) => registryId(stackIdFromRef(ref)) === base,
+      ),
+    )
+    .map((cat) => cat.id);
+  const [refs, io, stationRows, ...tagSlices] = await Promise.all([
+    entryEdges(dataset, ALL_KINDS, base, 'usedBy'),
+    index.fluids?.includes(base)
+      ? loadFluidIoIndex(dataset, index).catch(() => undefined)
+      : undefined,
+    Promise.all(
+      stationTypes.map((typeId) => loadTypeRows(dataset, index, typeId)),
+    ),
+    ...tagKinds.map((tagKind) => loadTagSlice(dataset, tagKind, ns)),
+  ]);
+  const tagKeys: string[] = [];
+  for (const [i, slice] of tagSlices.entries()) {
+    const registry = `${tagKinds[i]}s`;
+    for (const tag of slice[base] ?? slice[item] ?? []) {
+      const raw = tag.startsWith('#') ? tag.slice(1) : tag;
+      const parts = splitDumpId(raw);
+      if (parts) tagKeys.push(`${parts.ns}:${registry}/${parts.path}`);
+    }
+  }
+  const tagRefs = (
+    await Promise.all(
+      [...new Set(tagKeys)].map(async (key) => {
+        const parts = splitDumpId(key);
+        const tag = parts
+          ? await resolveClientTag(dataset, `${parts.ns}:${parts.path}`)
+          : undefined;
+        return tag?.usedBy ?? [];
+      }),
+    )
+  ).flat();
+  const ioRefs = io?.inputs.get(base) ?? [];
+  const allRefs = ioRefs.length
+    ? [...new Set([...refs, ...ioRefs])]
+    : refs;
+  return uniqueRows([
+    ...(await resolveRecipeRows(dataset, index, [...allRefs, ...tagRefs], opts)),
+    ...stationRows.flat(),
+  ]);
+}
+

package/src/lib/panel-outline.ts

@@ -0,0 +1,86 @@
+type OutlineRect = { x: number; y: number; w: number; h: number };
+
+type GroupOutline = {
+  groupId: string;
+  d: string;
+};
+
+const ptKey = (x: number, y: number) => `${x.toFixed(2)},${y.toFixed(2)}`;
+const edgeKey = (x1: number, y1: number, x2: number, y2: number) =>
+  `${ptKey(x1, y1)}>${ptKey(x2, y2)}`;
+
+export function groupOutlines(
+  indicesByGroup: Map<string, number[]>,
+  cols: number,
+  cell: OutlineRect,
+  gap: number,
+  bounds?: { w: number; h: number },
+  stroke = 0,
+): GroupOutline[] {
+  const pad = gap / 2;
+  const inset = stroke / 2;
+  const maxX = (bounds?.w ?? Number.POSITIVE_INFINITY) - inset;
+  const maxY = (bounds?.h ?? Number.POSITIVE_INFINITY) - inset;
+  const out: GroupOutline[] = [];
+  for (const [groupId, indices] of indicesByGroup) {
+    const cells = new Set(
+      indices.map((i) => `${i % cols},${Math.floor(i / cols)}`),
+    );
+    const segs: [number, number, number, number][] = [];
+    for (const i of indices) {
+      const col = i % cols;
+      const row = Math.floor(i / cols);
+      const x = Math.max(cell.x + col * (cell.w + gap) - pad, inset);
+      const y = Math.max(cell.y + row * (cell.h + gap) - pad, inset);
+      const w =
+        Math.min(cell.x + col * (cell.w + gap) + cell.w + pad, maxX) - x;
+      const h =
+        Math.min(cell.y + row * (cell.h + gap) + cell.h + pad, maxY) - y;
+      if (!cells.has(`${col},${row - 1}`)) segs.push([x, y, x + w, y]);
+      if (!cells.has(`${col},${row + 1}`)) segs.push([x, y + h, x + w, y + h]);
+      if (!cells.has(`${col - 1},${row}`)) segs.push([x, y, x, y + h]);
+      if (!cells.has(`${col + 1},${row}`)) segs.push([x + w, y, x + w, y + h]);
+    }
+    const adj = new Map<string, { x: number; y: number }[]>();
+    for (const [x1, y1, x2, y2] of segs) {
+      let a = adj.get(ptKey(x1, y1));
+      if (!a) adj.set(ptKey(x1, y1), (a = []));
+      a.push({ x: x2, y: y2 });
+      let b = adj.get(ptKey(x2, y2));
+      if (!b) adj.set(ptKey(x2, y2), (b = []));
+      b.push({ x: x1, y: y1 });
+    }
+    const used = new Set<string>();
+    for (const [x1, y1, x2, y2] of segs) {
+      const forward = edgeKey(x1, y1, x2, y2);
+      if (used.has(forward)) continue;
+      used.add(forward);
+      used.add(edgeKey(x2, y2, x1, y1));
+      const loop: [number, number][] = [
+        [x1, y1],
+        [x2, y2],
+      ];
+      let cx = x2;
+      let cy = y2;
+      while (cx !== x1 || cy !== y1) {
+        const next = (adj.get(ptKey(cx, cy)) ?? []).find(
+          (p) => !used.has(edgeKey(cx, cy, p.x, p.y)),
+        );
+        if (!next) break;
+        used.add(edgeKey(cx, cy, next.x, next.y));
+        used.add(edgeKey(next.x, next.y, cx, cy));
+        loop.push([next.x, next.y]);
+        cx = next.x;
+        cy = next.y;
+      }
+      if (loop.length > 2) {
+        out.push({
+          groupId,
+          d: `M${loop.map(([x, y]) => `${x.toFixed(2)} ${y.toFixed(2)}`).join(' L')} Z`,
+        });
+      }
+    }
+  }
+  return out;
+}
+

package/src/lib/panel.ts

@@ -0,0 +1,105 @@
+import {
+  stackIdFromRef,
+  type TaggedReference,
+} from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { registryId } from '@terrafirmagreg-team/dump/lib/dump/paths';
+import { recipeItemName } from '@terrafirmagreg-team/recipe/lib/client-index';
+import type { Lang } from '@terrafirmagreg-team/translate/types/locale';
+import type {
+  ItemPanelCell,
+  RecipeCompactIndex,
+  RecipeStackGroup,
+} from '@terrafirmagreg-team/recipe/types';
+
+function catalogPool(index: RecipeCompactIndex, tab?: string): string[] {
+  if (!tab) return index.items;
+  return index.tabItems?.[tab] ?? [];
+}
+
+export type ItemPanelMode = 'all' | 'fav';
+
+type ItemPanelTabRow = {
+  id: string;
+  icon: string;
+  iconRef?: TaggedReference;
+  help: string;
+};
+
+export function panelPool(
+  mode: ItemPanelMode,
+  favoriteIds: string[],
+  index: RecipeCompactIndex | null,
+  tab?: string,
+): string[] {
+  if (!index) return [];
+  return mode === 'fav' ? favoriteIds : catalogPool(index, tab);
+}
+
+export function buildPanelCells(
+  ids: readonly string[],
+  groups: RecipeStackGroup[] | undefined,
+  expandedGroups: ReadonlySet<string>,
+): ItemPanelCell[] {
+  if (!groups?.length) return ids.map((id) => ({ kind: 'stack', id }));
+  const byMember = new Map<string, RecipeStackGroup>();
+  for (const group of groups)
+    for (const member of group.members) {
+      const base = registryId(member);
+      if (!byMember.has(base)) byMember.set(base, group);
+    }
+  const inPool = new Set(ids.map(registryId));
+  const seen = new Set<string>();
+  const out: ItemPanelCell[] = [];
+  for (const id of ids) {
+    const base = registryId(id);
+    if (seen.has(base)) continue;
+    seen.add(base);
+    const group = byMember.get(base);
+    if (!group) {
+      out.push({ kind: 'stack', id });
+      continue;
+    }
+    const members = group.members.filter((member) =>
+      inPool.has(registryId(member)),
+    );
+    for (const member of members) seen.add(registryId(member));
+    if (members.length <= 1) {
+      out.push({ kind: 'stack', id: members[0] ?? id });
+      continue;
+    }
+    const expanded = expandedGroups.has(group.id);
+    out.push({
+      kind: 'group',
+      id: group.id,
+      label: group.name ?? group.id,
+      members,
+      expanded,
+    });
+    if (expanded)
+      for (const member of members)
+        out.push({ kind: 'stack', id: member, groupId: group.id });
+  }
+  return out;
+}
+
+export function panelTabRows(
+  index: RecipeCompactIndex | null,
+  names: Record<string, Record<string, string>>,
+  lang: Lang,
+): ItemPanelTabRow[] {
+  const rows: ItemPanelTabRow[] = [];
+  for (const row of index?.tabs ?? []) {
+    const icon =
+      (row.icon ? stackIdFromRef(row.icon) : undefined) ??
+      index?.tabItems?.[row.id]?.[0];
+    if (!icon) continue;
+    rows.push({
+      id: row.id,
+      icon,
+      iconRef: row.icon,
+      help: recipeItemName(names, lang, row.display.name ?? row.id),
+    });
+  }
+  return rows;
+}
+

package/src/lib/preview.ts

@@ -0,0 +1,32 @@
+import { registerPreviewResolver } from '@terrafirmagreg-team/preview/lib';
+import { clientDumpLang } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { loadDatasetRecipeCategories } from '@terrafirmagreg-team/recipe/lib/data/category/load';
+import { langString } from '@terrafirmagreg-team/dump/lib/dump/assets/lang/names';
+import { entryPreviewIcon } from '@terrafirmagreg-team/game/lib/preview';
+import type { PreviewResolverCtx } from '@terrafirmagreg-team/preview/lib';
+import type { PagePreviewData } from '@terrafirmagreg-team/ui/types/preview';
+
+export async function recipeLinkPreview({
+  parts,
+  query,
+  langMap,
+}: PreviewResolverCtx): Promise<PagePreviewData | undefined> {
+  const dataset = {
+    id: parts[1] ?? '',
+    version: query.get('version') ?? undefined,
+  };
+  if (!dataset.id) return undefined;
+  const type = query.get('type');
+  if (!type) return { title: 'Recipes' };
+  const categories = await loadDatasetRecipeCategories(dataset);
+  const row = categories.find((category) => category.id === type);
+  if (!row) return { title: type };
+  return {
+    title:
+      (row.display?.name && langString(langMap, row.display.name)) || row.id,
+    icon: entryPreviewIcon(row.icon, dataset),
+  };
+}
+
+registerPreviewResolver('recipe', recipeLinkPreview, { langMap: clientDumpLang });
+

package/src/lib/recipe-slots.ts

@@ -0,0 +1,8 @@
+import type { Recipe, RecipeSlotWidget } from '@terrafirmagreg-team/recipe/lib/data/dto';
+
+export function recipeSlots(recipe: Recipe): RecipeSlotWidget[] {
+  return recipe.widgets.filter(
+    (widget): widget is RecipeSlotWidget => widget.type === 'slot',
+  );
+}
+

package/src/lib/search.ts

@@ -0,0 +1,139 @@
+import { recipeItemName } from '@terrafirmagreg-team/recipe/lib/client-index';
+
+function matchesResolvedLabel(
+  id: string,
+  label: string,
+  needle: string,
+): boolean {
+  const q = needle.trim().toLowerCase();
+  if (!q) return true;
+  if (label.toLowerCase().includes(q)) return true;
+  const lower = id.toLowerCase();
+  return lower === q || lower.endsWith(`:${q}`) || lower.endsWith(`/${q}`);
+}
+
+type ItemSearchContext = {
+  names: Record<string, Record<string, string>>;
+  lang: string;
+  tagMembers?: Record<string, string[]>;
+  mods?: Record<string, string>;
+  tooltips?: Record<string, string[]>;
+};
+
+type SearchToken = {
+  negated: boolean;
+  kind: 'name' | 'mod' | 'tag' | 'tooltip';
+  needle: string;
+  regex?: RegExp;
+  memberSet?: Set<string>;
+};
+
+const TOKEN_RE = /-?[@#$]?(?:"[^"]*"|\/(?:\\.|[^\\/])*\/|[^\s]+)/g;
+
+function tokenize(query: string): SearchToken[][] {
+  return query
+    .split('|')
+    .map((branch) =>
+      (branch.match(TOKEN_RE) ?? [])
+        .flatMap((raw): SearchToken[] => {
+          if (!raw) return [];
+          const negated = raw.startsWith('-');
+          let token = negated ? raw.slice(1) : raw;
+          let kind: SearchToken['kind'] = 'name';
+          const prefix = token.charAt(0);
+          if (prefix === '@' || prefix === '#' || prefix === '$') {
+            kind = prefix === '@' ? 'mod' : prefix === '#' ? 'tag' : 'tooltip';
+            token = token.slice(1);
+          }
+          if (
+            token.length > 1 &&
+            token.startsWith('"') &&
+            token.endsWith('"')
+          ) {
+            token = token.slice(1, -1);
+          } else if (
+            token.length > 1 &&
+            token.startsWith('/') &&
+            token.endsWith('/')
+          ) {
+            try {
+              return [
+                {
+                  negated,
+                  kind,
+                  needle: '',
+                  regex: new RegExp(token.slice(1, -1), 'i'),
+                },
+              ];
+            } catch {}
+          }
+          const needle = token.trim().toLowerCase();
+          return needle ? [{ negated, kind, needle }] : [];
+        }),
+    )
+    .filter((branch) => branch.length > 0);
+}
+
+function tagMemberSet(token: SearchToken, ctx: ItemSearchContext): Set<string> {
+  const set = new Set<string>();
+  const test = (value: string) =>
+    token.regex
+      ? token.regex.test(value)
+      : value.toLowerCase().includes(token.needle);
+  for (const [tag, ids] of Object.entries(ctx.tagMembers ?? {})) {
+    if (test(tag) || test(recipeItemName(ctx.names, ctx.lang, tag))) {
+      for (const id of ids) set.add(id);
+    }
+  }
+  return set;
+}
+
+function matchToken(
+  token: SearchToken,
+  id: string,
+  label: string,
+  ctx: ItemSearchContext,
+): boolean {
+  const test = (value: string) =>
+    token.regex
+      ? token.regex.test(value)
+      : value.toLowerCase().includes(token.needle);
+  switch (token.kind) {
+    case 'mod': {
+      const ns = id.split(':')[0] ?? '';
+      const modName = (ctx.mods?.[ns] ?? '').toLowerCase().replace(/\s+/g, '');
+      return test(modName) || test(ns);
+    }
+    case 'tag': {
+      token.memberSet ??= tagMemberSet(token, ctx);
+      return token.memberSet.has(id);
+    }
+    case 'tooltip':
+      return (ctx.tooltips?.[id] ?? []).some((line) => test(line));
+    default:
+      if (token.regex) return token.regex.test(label) || token.regex.test(id);
+      return matchesResolvedLabel(id, label, token.needle);
+  }
+}
+
+function matchesGameItemSearch(
+  id: string,
+  ctx: ItemSearchContext,
+  groups: SearchToken[][],
+): boolean {
+  const label = recipeItemName(ctx.names, ctx.lang, id);
+  return groups.some((branch) =>
+    branch.every((token) => matchToken(token, id, label, ctx) !== token.negated),
+  );
+}
+
+export function filterCatalogItemIds(
+  ids: string[],
+  query: string,
+  ctx: ItemSearchContext,
+): string[] {
+  const groups = tokenize(query);
+  if (!groups.length) return ids;
+  return ids.filter((id) => matchesGameItemSearch(id, ctx, groups));
+}
+

package/src/lib/sidebar.ts

@@ -0,0 +1,47 @@
+import type * as PageTree from 'fumadocs-core/page-tree';
+
+function typeParamFromRecipeUrl(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  const query = url.split('?')[1];
+  if (!query) return undefined;
+  return new URLSearchParams(query).get('type') ?? undefined;
+}
+
+function collectRecipeLeaves(nodes: PageTree.Node[]): PageTree.Item[] {
+  const out: PageTree.Item[] = [];
+  for (const node of nodes) {
+    if (node.type === 'page') out.push(node);
+    else if (node.type === 'folder')
+      out.push(...collectRecipeLeaves(node.children));
+  }
+  return out;
+}
+
+export function groupRecipeSidebarByMod(
+  tree: PageTree.Root,
+  modNames: Record<string, string>,
+): PageTree.Root {
+  const leaves = collectRecipeLeaves(tree.children);
+  if (!leaves.length) return tree;
+  const byMod: Record<string, PageTree.Item[]> = {};
+  for (const leaf of leaves) {
+    const mod = typeParamFromRecipeUrl(leaf.url)?.split(':', 1)[0] ?? '_';
+    const list = byMod[mod];
+    if (list) list.push(leaf);
+    else byMod[mod] = [leaf];
+  }
+  const folders: PageTree.Folder[] = Object.entries(byMod)
+    .map(([mod, children]) => ({
+      type: 'folder' as const,
+      name: modNames[mod] ?? mod,
+      children,
+      $id: `mod/${mod}`,
+    }))
+    .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+  return {
+    name: tree.name,
+    children: folders,
+    $id: `${tree.$id}:mod`,
+  };
+}
+

package/src/lib/used-items.ts

@@ -0,0 +1,25 @@
+import { registryId } from '@terrafirmagreg-team/recipe/lib/lookup';
+import type { RecipeCompactIndex, UsedItems } from '@terrafirmagreg-team/recipe/types';
+
+export function recipeUsedItems(index: RecipeCompactIndex | null): UsedItems {
+  const ids = new Set<string>();
+  const bases = new Set<string>();
+  for (const id of index?.usedIds ?? []) {
+    ids.add(id);
+    bases.add(registryId(id));
+  }
+  return { ids, bases };
+}
+
+function isRecipeUsed(id: string, used: UsedItems): boolean {
+  return used.ids.has(id) || used.bases.has(registryId(id));
+}
+
+export function filterUsedIds(ids: string[], used: UsedItems): string[] {
+  return ids.filter((id) => isRecipeUsed(id, used));
+}
+
+export function hasRecipeUsage(used: UsedItems): boolean {
+  return used.ids.size > 0;
+}
+