@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/client-index/registry.ts

@@ -0,0 +1,121 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { clientDumpJson } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { loadClientTagMembers } from '@terrafirmagreg-team/dump/lib/dump/client/tags';
+import {
+  asRecord,
+  asStringList,
+  resolveEdgeRows,
+} from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import { stackIdBase } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+const REGISTRY_FIELD: Record<
+  string,
+  'items' | 'blocks' | 'fluids' | 'entities'
+> = {
+  item: 'items',
+  block: 'blocks',
+  fluid: 'fluids',
+  entity: 'entities',
+};
+
+function registryField(kind: string) {
+  return REGISTRY_FIELD[kind] ?? 'items';
+}
+
+const registrySliceCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    kind: string,
+  ): Promise<Record<string, Record<string, unknown>>> => {
+    const field = registryField(kind);
+    const raw = await clientDumpJson(dataset, `registry/${field}.json`);
+    const map = asRecord(raw);
+    return map ? resolveEdgeRows(map) : {};
+  },
+  (dataset, kind) => `${dataset.id}/${dataset.version ?? ''} ${registryField(kind)}`,
+);
+
+function loadRegistryFile(
+  dataset: DatasetRef,
+  kind: string,
+): Promise<Record<string, Record<string, unknown>>> {
+  return registrySliceCache(dataset, kind);
+}
+
+export async function loadRegistryEntrySlice(
+  dataset: DatasetRef,
+  kind: string,
+  id: string,
+): Promise<Record<string, unknown> | undefined> {
+  const base = stackIdBase(id);
+  const map = await loadRegistryFile(dataset, kind);
+  return map[id] ?? map[base];
+}
+
+const tagSliceCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    kind: string,
+    ns: string,
+  ): Promise<Record<string, string[]>> => {
+    const prefix = `${ns}:`;
+    const map = await loadRegistryFile(dataset, kind);
+    const out: Record<string, string[]> = {};
+    for (const [id, entry] of Object.entries(map)) {
+      if (!id.startsWith(prefix)) continue;
+      const tags = asStringList(entry.tags);
+      if (tags.length) out[id] = tags;
+    }
+    return out;
+  },
+);
+
+export function loadTagSlice(
+  dataset: DatasetRef,
+  kind: string,
+  ns: string,
+): Promise<Record<string, string[]>> {
+  return tagSliceCache(dataset, kind, ns);
+}
+
+const tagMembersByKindCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    kind: string,
+  ): Promise<Record<string, string[]>> => {
+    const memberKind = registryField(kind) === 'blocks' ? 'block' : 'item';
+    return (await loadClientTagMembers(dataset, memberKind)) ?? {};
+  },
+  (dataset, kind) =>
+    `${dataset.id}/${dataset.version ?? ''} ${registryField(kind) === 'blocks' ? 'block' : 'item'}`,
+);
+
+const allTagMembersCache = createDatasetCache(
+  async (dataset: DatasetRef): Promise<Record<string, string[]>> => {
+    const [items, blocks] = await Promise.all([
+      loadTagMembersByKind(dataset, 'item'),
+      loadTagMembersByKind(dataset, 'block'),
+    ]);
+    const merged: Record<string, string[]> = { ...items };
+    for (const [tag, ids] of Object.entries(blocks)) {
+      merged[tag] = merged[tag] ? [...merged[tag], ...ids] : ids;
+    }
+    return merged;
+  },
+  (dataset) => `${dataset.id}/${dataset.version ?? ''} all`,
+);
+
+function loadTagMembersByKind(
+  dataset: DatasetRef,
+  kind: string,
+): Promise<Record<string, string[]>> {
+  return tagMembersByKindCache(dataset, kind);
+}
+
+export function loadAllTagMembers(
+  dataset: DatasetRef,
+): Promise<Record<string, string[]>> {
+  return allTagMembersCache(dataset);
+}
+

package/src/lib/client-index/rows.ts

@@ -0,0 +1,260 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type {
+  RecipeCompactIndex,
+  RecipeCompactRow,
+} from '@terrafirmagreg-team/recipe/types';
+import { clientDumpJson, loadClientManifest } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { dumpRelPublicUrl } from '@terrafirmagreg-team/dump/lib/dump/paths';
+import { asNumber, asRecord, asString } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import {
+  asTaggedReference,
+  stackIdFromRef,
+} from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import type { RecipeTypeRow } from '@terrafirmagreg-team/dump/lib/dump/manifest/dto';
+import {
+  clientRecipeFileRels,
+  loadClientRecipe,
+} from '@terrafirmagreg-team/recipe/lib/client/recipe';
+import {
+  outputBoundary,
+  slotIoRole,
+} from '@terrafirmagreg-team/recipe/lib/data/slot-io';
+import type { DumpRecipeLayout } from '@terrafirmagreg-team/recipe/lib/data/category/dto';
+import type {
+  Recipe,
+  RecipeSlotType,
+} from '@terrafirmagreg-team/recipe/lib/data/dto';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+const typeRowsCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    index: RecipeCompactIndex,
+    typeId: string,
+  ): Promise<RecipeCompactRow[]> => {
+    const typeIndex = index.types.indexOf(typeId);
+    if (typeIndex < 0) return [];
+    const row = (await recipeTypeRows(dataset)).find(
+      (entry) => entry.id === typeId,
+    );
+    if (!row?.files) return [];
+    const layout = categoryLayout(index, typeId);
+    const buckets = await Promise.all(
+      Object.values(row.files).map(async (rel) => {
+        if (!rel) return [];
+        const bucket = await loadBucket(dataset, rel);
+        return Object.entries(bucket).flatMap(([id, raw]) => {
+          const parsed = rowFromBucketEntry(
+            dataset,
+            id,
+            raw,
+            typeIndex,
+            rel,
+            layout,
+          );
+          return parsed ? [parsed] : [];
+        });
+      }),
+    );
+    return buckets
+      .flat()
+      .sort(
+        (a, b) =>
+          (a.o ?? Number.MAX_SAFE_INTEGER) - (b.o ?? Number.MAX_SAFE_INTEGER),
+      );
+  },
+  (dataset, _index, typeId) => `${dataset.id}/${dataset.version ?? ''} ${typeId}`,
+);
+
+const bucketCache = createDatasetCache(
+  async (dataset: DatasetRef, rel: string): Promise<Record<string, unknown>> => {
+    const raw = await clientDumpJson(dataset, rel, 'high');
+    return asRecord(raw) ?? {};
+  },
+  (dataset, rel) => `${dataset.id}/${dataset.version ?? ''} ${rel}`,
+);
+
+export async function recipeTypeRows(
+  dataset: DatasetRef,
+): Promise<RecipeTypeRow[]> {
+  const manifest = await loadClientManifest(dataset);
+  return manifest?.indexes.recipes.types ?? [];
+}
+
+const categoryLayoutCache = new WeakMap<
+  RecipeCompactIndex,
+  Map<string, DumpRecipeLayout>
+>();
+
+function categoryLayout(
+  index: RecipeCompactIndex,
+  typeId: string | undefined,
+): DumpRecipeLayout | undefined {
+  if (!typeId) return undefined;
+  let map = categoryLayoutCache.get(index);
+  if (!map) {
+    map = new Map();
+    for (const cat of index.categories ?? []) {
+      if (cat.layout) map.set(cat.id, cat.layout);
+    }
+    categoryLayoutCache.set(index, map);
+  }
+  return map.get(typeId);
+}
+
+function slotRefIds(
+  raw: unknown,
+  role: 'input' | 'output',
+  layout?: DumpRecipeLayout,
+): string[] {
+  const slots = asRecord(raw);
+  if (!slots) return [];
+  const boundary = outputBoundary(
+    slots as Record<string, { type?: unknown; x?: unknown } | undefined>,
+    layout,
+  );
+  const laid = layout
+    ? new Map(layout.slots.map((slot) => [slot.id, slot]))
+    : undefined;
+  const out: string[] = [];
+  for (const [slotId, slot] of Object.entries(slots)) {
+    const row = asRecord(slot);
+    const ref = asTaggedReference(row?.ref);
+    if (!ref) continue;
+    const slotType = asString(row?.type) ?? 'input';
+    const x = asNumber(row?.x) ?? laid?.get(slotId)?.x;
+    if (slotIoRole(slotType as RecipeSlotType, x, boundary) === role) {
+      out.push(stackIdFromRef(ref));
+    }
+  }
+  return out;
+}
+
+function rowFromBucketEntry(
+  dataset: DatasetRef,
+  id: string,
+  raw: unknown,
+  typeIndex: number,
+  rel: string,
+  layout?: DumpRecipeLayout,
+): RecipeCompactRow | undefined {
+  const recipe = asRecord(raw);
+  if (!recipe) return undefined;
+  const w = asNumber(recipe.w);
+  const h = asNumber(recipe.h);
+  const image = asString(recipe.image);
+  const order = asNumber(recipe.order);
+  return {
+    id,
+    type: typeIndex,
+    ...(order != null ? { o: order } : {}),
+    in: slotRefIds(recipe.slots, 'input', layout),
+    out: slotRefIds(recipe.slots, 'output', layout),
+    bodyUrl: dumpRelPublicUrl(dataset, rel),
+    ...(image ? { image } : {}),
+    bucket: rel,
+    ...(w != null && h != null ? { d: { w, h } } : {}),
+  };
+}
+
+function loadBucket(
+  dataset: DatasetRef,
+  rel: string,
+): Promise<Record<string, unknown>> {
+  return bucketCache(dataset, rel);
+}
+
+export function loadTypeRows(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+  typeId: string,
+): Promise<RecipeCompactRow[]> {
+  return typeRowsCache(dataset, index, typeId);
+}
+
+export async function loadCategoryRecipes(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+  typeId: string,
+): Promise<Recipe[]> {
+  const rows = await loadTypeRows(dataset, index, typeId);
+  const seen = new Set<string>();
+  const recipes = await Promise.all(
+    rows.map(async (row) => {
+      if (seen.has(row.id)) return undefined;
+      seen.add(row.id);
+      const recipe = await loadClientRecipe(dataset, row.id, row.bucket);
+      if (!recipe || recipe.type !== typeId) return undefined;
+      return recipe;
+    }),
+  );
+  return recipes.filter((recipe) => recipe !== undefined);
+}
+
+export const TAG_RECIPE_TYPE = 'emi:tag';
+
+export async function resolveRecipeRows(
+  dataset: DatasetRef,
+  index: RecipeCompactIndex,
+  ids: Iterable<string>,
+  opts?: { includeTagRows?: boolean },
+): Promise<RecipeCompactRow[]> {
+  const includeTagRows = opts?.includeTagRows ?? true;
+  const wanted = new Set<string>();
+  const byBucket = new Map<string, Set<string>>();
+  for (const id of ids) {
+    if (!id || wanted.has(id)) continue;
+    wanted.add(id);
+    const rels = await clientRecipeFileRels(dataset, id);
+    for (const rel of rels) {
+      const set = byBucket.get(rel);
+      if (set) set.add(id);
+      else byBucket.set(rel, new Set([id]));
+    }
+  }
+  const out: RecipeCompactRow[] = [];
+  const seen = new Set<string>();
+  await Promise.all(
+    [...byBucket.entries()].map(async ([rel, idsInBucket]) => {
+      const bucket = await loadBucket(dataset, rel);
+      for (const id of idsInBucket) {
+        const raw = bucket[id];
+        const category = asString(asRecord(raw)?.category);
+        const typeIndex = category ? index.types.indexOf(category) : -1;
+        if (!includeTagRows && category === TAG_RECIPE_TYPE) continue;
+        const row = rowFromBucketEntry(
+          dataset,
+          id,
+          raw,
+          typeIndex < 0 ? 0 : typeIndex,
+          rel,
+          categoryLayout(index, category),
+        );
+        if (row && typeIndex < 0 && category) row.cat = category;
+        if (row && !seen.has(row.id)) {
+          seen.add(row.id);
+          out.push(row);
+        }
+      }
+    }),
+  );
+
+  const byBase = new Map<string, RecipeCompactRow>();
+  for (const row of out) {
+    const base = row.id.replace(/\/dup_\d+$/, '');
+    const key = `${row.type}:${base}`;
+    const prev = byBase.get(key);
+    if (
+      !prev ||
+      (/\/dup_\d+$/.test(prev.id) && !/\/dup_\d+$/.test(row.id))
+    ) {
+      byBase.set(key, row);
+    }
+  }
+  const deduped = [...byBase.values()];
+  deduped.sort(
+    (a, b) => (a.o ?? Number.MAX_SAFE_INTEGER) - (b.o ?? Number.MAX_SAFE_INTEGER),
+  );
+  return deduped;
+}
+

package/src/lib/client-index/tooltips.ts

@@ -0,0 +1,74 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { clientDumpLang } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { loadClientKeybinds } from '@terrafirmagreg-team/dump/lib/dump/client/keybinds';
+import {
+  loadClientRegistryTooltips,
+  loadClientRegistryTooltipsMod,
+} from '@terrafirmagreg-team/dump/lib/dump/client/registry';
+import { dumpTextLines } from '@terrafirmagreg-team/dump/lib/dump/assets/lang/names';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+const TOOLTIP_MODS = ['shift', 'ctrl', 'alt'] as const;
+
+const tooltipsApiCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    lang: string,
+  ): Promise<{
+    lines: Record<string, string[]>;
+    mods: Record<string, Record<string, string[]>>;
+  }> => {
+    const kinds = ['item', 'block', 'fluid', 'entity'] as const;
+    const [map, keybinds, shards, modShards] = await Promise.all([
+      clientDumpLang(dataset, lang),
+      loadClientKeybinds(dataset),
+      Promise.all(
+        kinds.map((kind) => loadClientRegistryTooltips(dataset, kind)),
+      ),
+      Promise.all(
+        kinds.flatMap((kind, kindIndex) =>
+          TOOLTIP_MODS.map(async (mod) => ({
+            kindIndex,
+            mod,
+            shard: await loadClientRegistryTooltipsMod(dataset, kind, mod),
+          })),
+        ),
+      ),
+    ]);
+    const lines: Record<string, string[]> = {};
+    const mods: Record<string, Record<string, string[]>> = {};
+    for (const shard of shards) {
+      for (const [id, raw] of Object.entries(shard ?? {})) {
+        if (id in lines) continue;
+        const resolved = dumpTextLines(map, raw, keybinds);
+        if (resolved.length) lines[id] = resolved;
+      }
+    }
+    for (const { mod, shard } of modShards) {
+      const table = (mods[mod] ??= {});
+      for (const [id, raw] of Object.entries(shard ?? {})) {
+        if (id in table) continue;
+        const resolved = dumpTextLines(map, raw, keybinds);
+        if (resolved.length) table[id] = resolved;
+      }
+    }
+    return { lines, mods };
+  },
+);
+
+const tooltipsCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    lang: string,
+  ): Promise<Record<string, string[]>> =>
+    (await tooltipsApiCache(dataset, lang)).lines,
+  (dataset, lang) => `${dataset.id}/${dataset.version ?? ''} ${lang}`,
+);
+
+export async function loadItemTooltips(
+  dataset: DatasetRef,
+  lang: string,
+): Promise<Record<string, string[]>> {
+  return tooltipsCache(dataset, lang);
+}
+

package/src/lib/config.ts

@@ -0,0 +1,18 @@
+import { createConfigRegistry, uiConfig } from '@terrafirmagreg-team/ui/lib/config';
+import { registerMdxComponents } from '@terrafirmagreg-team/mdx/components/mdx-components';
+import { Recipe } from '@terrafirmagreg-team/recipe/components/mdx/recipe';
+import '@terrafirmagreg-team/recipe/lib/preview';
+
+export type RecipeConfigInput = {
+  appName?: string;
+};
+
+const { register: registerRecipeConfig, get: recipeConfig } =
+  createConfigRegistry<RecipeConfigInput, { appName: string }>((overrides) => ({
+    appName: overrides.appName ?? uiConfig().brand?.name ?? '',
+  }));
+
+export { registerRecipeConfig, recipeConfig };
+
+registerMdxComponents({ Recipe });
+

package/src/lib/data/category/dto.ts

@@ -0,0 +1,25 @@
+import type { DumpDisplay } from '@terrafirmagreg-team/dump/lib/dump/contract/text';
+import type { TaggedReference } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import type {
+  RecipeCategory,
+  RecipeCategoryLayout,
+  RecipeLayoutSlot,
+} from '@terrafirmagreg-team/dump/lib/dump/gen';
+
+export type DumpLayoutSlot = RecipeLayoutSlot;
+
+export type DumpRecipeLayout = Omit<RecipeCategoryLayout, 'slots'> & {
+  slots: DumpLayoutSlot[];
+};
+
+export type DumpRecipeCategory = Omit<
+  RecipeCategory,
+  'display' | 'icon' | 'layout' | 'workstations'
+> & {
+  id: string;
+  display?: DumpDisplay;
+  icon?: TaggedReference;
+  workstations?: TaggedReference[];
+  layout?: DumpRecipeLayout;
+};
+

package/src/lib/data/category/load.ts

@@ -0,0 +1,47 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { asCategory } from '@terrafirmagreg-team/recipe/lib/data/category/parse';
+import type { DumpRecipeCategory } from '@terrafirmagreg-team/recipe/lib/data/category/dto';
+import { loadDatasetDump } from '@terrafirmagreg-team/dump/lib/dump/mods/load';
+import { clientDumpJson } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { asRecord } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+const cache = createDatasetCache(
+  async (dataset: DatasetRef): Promise<DumpRecipeCategory[]> => {
+    const out: DumpRecipeCategory[] = [];
+    const dump = await loadDatasetDump(dataset);
+    if (dump) {
+      const seen = new Set<string>();
+      const rows = await Promise.all(
+        dump.mods.flatMap((ns) => {
+          if (!ns.recipeCategories || seen.has(ns.recipeCategories)) {
+            return [];
+          }
+          seen.add(ns.recipeCategories);
+          return [clientDumpJson(dataset, ns.recipeCategories)];
+        }),
+      );
+      for (const row of rows) {
+        const entries = asRecord(row);
+        if (!entries) continue;
+        for (const [catalogKey, raw] of Object.entries(entries)) {
+          const cat = asCategory(
+            raw && typeof raw === 'object' && !Array.isArray(raw) && !('id' in raw)
+              ? { ...raw, id: catalogKey }
+              : raw,
+          );
+          if (cat) out.push(cat);
+        }
+      }
+    }
+    out.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+    return out;
+  },
+);
+
+export function loadDatasetRecipeCategories(
+  dataset: DatasetRef,
+): Promise<DumpRecipeCategory[]> {
+  return cache(dataset);
+}
+

package/src/lib/data/category/parse.ts

@@ -0,0 +1,71 @@
+import { asNumber, asRecord, asString } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import { asTaggedReference } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import { asDisplay } from '@terrafirmagreg-team/dump/lib/dump/contract/text';
+import type {
+  DumpLayoutSlot,
+  DumpRecipeCategory,
+  DumpRecipeLayout,
+} from '@terrafirmagreg-team/recipe/lib/data/category/dto';
+
+function asLayoutSlot(value: unknown, key: string): DumpLayoutSlot | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const id = asString(row.id) ?? key;
+  if (!id) return undefined;
+  const x = asNumber(row.x) ?? 0;
+  const y = asNumber(row.y) ?? 0;
+  const w = asNumber(row.w) ?? 18;
+  const h = asNumber(row.h) ?? 18;
+  const role = asString(row.role) ?? 'input';
+  return { id, x, y, w, h, role };
+}
+
+function asLayout(value: unknown): DumpRecipeLayout | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const w = asNumber(row.w);
+  const h = asNumber(row.h);
+  if (w === undefined || h === undefined) return undefined;
+  const scale = asNumber(row.scale);
+  const margin = asNumber(row.margin);
+  const image = asString(row.image);
+  const slotsRow = asRecord(row.slots);
+  const slots = Object.entries(slotsRow ?? {}).flatMap(([key, item]) => {
+    const slot = asLayoutSlot(item, key);
+    return slot ? [slot] : [];
+  });
+  return {
+    w,
+    h,
+    ...(scale !== undefined ? { scale } : {}),
+    ...(margin !== undefined ? { margin } : {}),
+    ...(image ? { image } : {}),
+    slots,
+  };
+}
+
+export function asCategory(value: unknown): DumpRecipeCategory | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const id = asString(row.id);
+  if (!id) return undefined;
+  const display = asDisplay(row.display);
+  const order = asNumber(row.order) ?? 0;
+  const icon = asTaggedReference(row.icon);
+  const workstations = Array.isArray(row.workstations)
+    ? row.workstations.flatMap((item) => {
+        const ref = asTaggedReference(item);
+        return ref ? [ref] : [];
+      })
+    : undefined;
+  const layout = asLayout(row.layout);
+  return {
+    id,
+    order,
+    ...(display ? { display } : {}),
+    ...(icon ? { icon } : {}),
+    ...(workstations && workstations.length > 0 ? { workstations } : {}),
+    ...(layout ? { layout } : {}),
+  };
+}
+