@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/calc/worker/protocol.ts

@@ -0,0 +1,35 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type { RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
+import type {
+  CalcRecipe,
+  TagResolution,
+} from '@terrafirmagreg-team/recipe/types/calc';
+
+export type ResolveInput = {
+  materials?: string[];
+  recipes?: string[];
+  tags?: string[];
+};
+
+export type CalcWorkerFlush = {
+  epoch: number;
+  out: [string, RecipeCompactRow[]][];
+  tag: [string, TagResolution][];
+  recipes: [string, CalcRecipe][];
+  bodies: [string, Recipe][];
+  dead: string[];
+};
+
+export type FlushHandler = (msg: CalcWorkerFlush) => void;
+
+export type CalcWorkerApi = {
+  init(
+    dataset: DatasetRef,
+    catalog: unknown,
+    flushHandler: FlushHandler,
+  ): Promise<void>;
+  resolve(input: ResolveInput): Promise<void>;
+  invalidate(): Promise<void>;
+};
+

package/src/lib/calc/worker/resolve.ts

@@ -0,0 +1,49 @@
+import { fetchWanted } from './fetch';
+import { createFlush, postFlush } from './flush';
+import type { ResolveInput } from './protocol';
+import { state } from './state';
+
+export async function runResolve(input: ResolveInput) {
+  const gen = state.resolveGen;
+  const pending = createFlush();
+  const wantedRecipes = new Set(
+    (input.recipes ?? []).filter(
+      (id) => id && !state.recipeMap.has(id) && !state.deadIds.has(id),
+    ),
+  );
+  const wantedOut = new Set(
+    (input.materials ?? []).filter((id) => id && !state.outMap.has(id)),
+  );
+  const wantedTag = new Set(
+    (input.tags ?? []).filter((id) => id && !state.tagMap.has(id)),
+  );
+  for (let iter = 0; iter < 50; iter += 1) {
+    if (gen !== state.resolveGen) return;
+    if (!wantedRecipes.size && !wantedOut.size && !wantedTag.size) break;
+    const progressed = await fetchWanted(
+      pending,
+      wantedRecipes,
+      wantedOut,
+      wantedTag,
+      state.recipeMap,
+    );
+    if (gen !== state.resolveGen) return;
+    if (!progressed) break;
+    for (const id of input.tags ?? []) {
+      if (id && !state.tagMap.has(id)) wantedTag.add(id);
+    }
+    wantedRecipes.forEach((id) => {
+      if (state.recipeMap.has(id) || state.deadIds.has(id)) {
+        wantedRecipes.delete(id);
+      }
+    });
+    wantedOut.forEach((id) => {
+      if (state.outMap.has(id)) wantedOut.delete(id);
+    });
+    wantedTag.forEach((id) => {
+      if (state.tagMap.has(id)) wantedTag.delete(id);
+    });
+  }
+  postFlush(pending);
+}
+

package/src/lib/calc/worker/state.ts

@@ -0,0 +1,48 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type { RecipeCompactIndex, RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
+import type { CalcRecipe, TagResolution } from '@terrafirmagreg-team/recipe/types/calc';
+import type { FlushHandler } from './protocol';
+
+export type CalcWorkerState = {
+  dataset: DatasetRef;
+  catalog: RecipeCompactIndex | null;
+  onFlush: FlushHandler;
+  outMap: Map<string, RecipeCompactRow[]>;
+  tagMap: Map<string, TagResolution>;
+  recipeMap: Map<string, CalcRecipe>;
+  bodyMap: Map<string, Recipe>;
+  deadIds: Set<string>;
+
+  epoch: number;
+  resolveGen: number;
+};
+
+export const state: CalcWorkerState = {
+  dataset: { id: '' },
+  catalog: null,
+  onFlush: () => {},
+  outMap: new Map(),
+  tagMap: new Map(),
+  recipeMap: new Map(),
+  bodyMap: new Map(),
+  deadIds: new Set(),
+  epoch: 0,
+  resolveGen: 0,
+};
+
+export function resetWorkerState(
+  nextDataset: DatasetRef,
+  nextCatalog: RecipeCompactIndex,
+) {
+  state.dataset = nextDataset;
+  state.catalog = nextCatalog;
+  state.resolveGen += 1;
+  state.epoch += 1;
+  state.outMap.clear();
+  state.tagMap.clear();
+  state.recipeMap.clear();
+  state.bodyMap.clear();
+  state.deadIds.clear();
+}
+

package/src/lib/card-model.ts

@@ -0,0 +1,65 @@
+import type {
+  RecipeSlotWidget,
+  RecipeTextWidget,
+} from '@terrafirmagreg-team/recipe/lib/data/dto';
+
+export type CardStripGeo = {
+  slots: RecipeSlotWidget[];
+  top: number;
+  bottom: number;
+  right: number;
+  overflow: boolean;
+  patchBottom: number;
+  barTop: number;
+};
+
+export function cardStripGeo(
+  slots: RecipeSlotWidget[],
+  contentGuiW: number,
+  innerBottomGui: number,
+  margin: number,
+): CardStripGeo {
+  const stripSlots = slots.filter((slot) => slot.role === 'renderOnly');
+  const top = stripSlots.length
+    ? Math.min(...stripSlots.map((slot) => slot.y))
+    : 0;
+  const bottom = stripSlots.length
+    ? Math.max(...stripSlots.map((slot) => slot.y + slot.h))
+    : 0;
+  const right = stripSlots.length
+    ? Math.max(...stripSlots.map((slot) => slot.x + slot.w))
+    : 0;
+  const overflow = right > contentGuiW + 1;
+  const patchBottom = Math.min(
+    bottom + margin + 16,
+    Math.max(innerBottomGui - 1, 0),
+  );
+  const barTop = Math.min(bottom + margin + 1, Math.max(innerBottomGui - 5, 0));
+  return { slots: stripSlots, top, bottom, right, overflow, patchBottom, barTop };
+}
+
+export function countCoveredText(
+  widget: RecipeTextWidget,
+  stripSlots: RecipeSlotWidget[],
+): boolean {
+  return stripSlots.some(
+    (slot) =>
+      slot.count !== undefined &&
+      String(slot.count) === widget.text &&
+      widget.x + widget.w > slot.x &&
+      widget.x < slot.x + slot.w,
+  );
+}
+
+export function textInStrip(
+  widget: RecipeTextWidget,
+  geo: CardStripGeo,
+): boolean {
+  return (
+    geo.overflow &&
+    widget.y + widget.h > geo.top &&
+    widget.y < geo.bottom &&
+    widget.x < geo.right
+  );
+}
+

package/src/lib/client/recipe-categories.ts

@@ -0,0 +1,14 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { loadDatasetRecipeCategories } from '@terrafirmagreg-team/recipe/lib/data/category/load';
+import type { DumpRecipeLayout } from '@terrafirmagreg-team/recipe/lib/data/category/dto';
+
+export function clientRecipeLayout(
+  dataset: DatasetRef,
+  categoryId: string,
+): Promise<DumpRecipeLayout | undefined> {
+  return loadDatasetRecipeCategories(dataset).then(
+    (categories) =>
+      categories.find((cat) => cat.id === categoryId)?.layout,
+  );
+}
+

package/src/lib/client/recipe.ts

@@ -0,0 +1,85 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import { asRecord, asString } from '@terrafirmagreg-team/dump/lib/dump/contract/read';
+import { parseRecipe } from '@terrafirmagreg-team/recipe/lib/data/parse';
+import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import { dumpRelPublicUrl } from '@terrafirmagreg-team/dump/lib/dump/paths';
+import {
+  clientDumpJson,
+  loadClientManifest,
+} from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import { clientRecipeLayout } from '@terrafirmagreg-team/recipe/lib/client/recipe-categories';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+const recipeIndex = createDatasetCache(async (dataset: DatasetRef, ns: string) => {
+  const manifest = await loadClientManifest(dataset);
+  const listed = manifest?.namespaces[ns];
+  if (!listed || !listed.registry.includes('recipes')) return undefined;
+  return asRecord(
+    await clientDumpJson(dataset, 'registry/recipes.json', 'high'),
+  ) as Record<string, string | string[]> | undefined;
+});
+
+export async function clientRecipeFileRels(
+  dataset: DatasetRef,
+  recipeId: string,
+): Promise<string[]> {
+  const ns = recipeId.split(':', 1)[0];
+  if (!ns) return [];
+  const index = await recipeIndex(dataset, ns);
+  const value = index?.[recipeId];
+  const categories = Array.isArray(value)
+    ? value
+    : typeof value === 'string'
+      ? [value]
+      : [];
+  return categories
+    .filter(
+      (category): category is string =>
+        typeof category === 'string' && !!category,
+    )
+    .map((category) =>
+      category.includes(':')
+        ? category.slice(category.indexOf(':') + 1)
+        : category,
+    )
+    .filter((path) => !!path)
+    .map((path) => `data/${ns}/recipes/${path}.json`);
+}
+
+async function clientRecipeFileRel(
+  dataset: DatasetRef,
+  recipeId: string,
+): Promise<string | undefined> {
+  return (await clientRecipeFileRels(dataset, recipeId))[0];
+}
+
+export const loadClientRecipe: (
+  dataset: DatasetRef,
+  id: string,
+  bucket?: string,
+) => Promise<Recipe | undefined> = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    id: string,
+    bucket?: string,
+  ): Promise<Recipe | undefined> => {
+    const rel = bucket ?? (await clientRecipeFileRel(dataset, id));
+    if (!rel) return undefined;
+    const doc = asRecord(await clientDumpJson(dataset, rel, 'high'));
+    const raw = doc?.[id];
+    if (raw === undefined) return undefined;
+    const ns = rel.split('/')[1] ?? '';
+    const category = asString(asRecord(raw)?.category);
+    const layout = category
+      ? await clientRecipeLayout(dataset, category)
+      : undefined;
+    return parseRecipe(raw, {
+      modId: ns,
+      bodyUrl: dumpRelPublicUrl(dataset, rel) ?? `/${dataset.id}`,
+      id,
+      ...(layout ? { layout } : {}),
+    });
+  },
+  (dataset, id, bucket) => JSON.stringify([dataset, id, bucket ?? '']),
+);
+

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

@@ -0,0 +1,91 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { RecipeChrome, RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
+import { loadDatasetRecipeCategories } from '@terrafirmagreg-team/recipe/lib/data/category/load';
+import { stackDisplayName } from '@terrafirmagreg-team/game/lib/entry/display';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+import { recipeTypeRows } from './rows';
+
+const emptyRecipeIndex = (): RecipeCompactIndex => ({
+  types: [],
+  items: [],
+  names: {},
+});
+
+async function loadRecipeStructureFromDump(
+  dataset: DatasetRef,
+  chrome: RecipeChrome,
+): Promise<RecipeCompactIndex> {
+  const rows = await recipeTypeRows(dataset);
+  const typeCounts: Record<string, number> = {};
+  for (const row of rows) {
+    if (row.id) typeCounts[row.id] = row.count ?? 0;
+  }
+  return {
+    types: rows.map((row) => row.id),
+    typeCounts,
+    items: chrome.items,
+    names: chrome.names,
+    ...(chrome.fluids?.length ? { fluids: chrome.fluids } : {}),
+    ...(chrome.usedIds?.length ? { usedIds: chrome.usedIds } : {}),
+    ...(chrome.tabs?.length ? { tabs: chrome.tabs } : {}),
+    ...(chrome.tabItems ? { tabItems: chrome.tabItems } : {}),
+    ...(chrome.categories?.length ? { categories: chrome.categories } : {}),
+    ...(chrome.mods ? { mods: chrome.mods } : {}),
+    ...(chrome.groups?.length ? { groups: chrome.groups } : {}),
+  };
+}
+
+const indexCache = createDatasetCache(
+  async (
+    dataset: DatasetRef,
+    chrome?: RecipeChrome,
+  ): Promise<RecipeCompactIndex> => {
+    if (!chrome) return emptyRecipeIndex();
+    return loadRecipeStructureFromDump(dataset, chrome);
+  },
+  (dataset, chrome) =>
+    `${dataset.id}/${dataset.version ?? ''} ${chrome ? (Object.keys(chrome.names)[0] ?? '') : ''}`,
+);
+
+const skeletonCache = createDatasetCache(
+  async (dataset: DatasetRef): Promise<RecipeCompactIndex> =>
+    loadDatasetRecipeCategories(dataset).then((categories) =>
+      loadRecipeStructureFromDump(dataset, {
+        items: [],
+        names: {},
+        ...(categories.length ? { categories } : {}),
+      }),
+    ),
+);
+
+export function loadRecipeCompactIndex(
+  dataset: DatasetRef,
+  chrome?: RecipeChrome,
+): Promise<RecipeCompactIndex> {
+  return indexCache(dataset, chrome);
+}
+
+export function loadRecipeSkeletonIndex(
+  dataset: DatasetRef,
+): Promise<RecipeCompactIndex> {
+  return skeletonCache(dataset);
+}
+
+export function nonEmptyCategoryIds(
+  index: RecipeCompactIndex | null,
+): string[] {
+  const counts = index?.typeCounts;
+  if (!counts) return [];
+  return (index?.categories ?? [])
+    .map((row) => row.id)
+    .filter((id) => (counts[id] ?? 0) > 0);
+}
+
+export function recipeItemName(
+  names: Record<string, Record<string, string>>,
+  lang: string,
+  id: string,
+): string {
+  return stackDisplayName(names[lang] ?? names.en_us, id);
+}
+

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

@@ -0,0 +1,180 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type {
+  RecipeCategory,
+  RecipeChrome,
+  RecipeStackGroup,
+} from '@terrafirmagreg-team/recipe/types';
+import { clientDumpLang, loadClientManifest } from '@terrafirmagreg-team/dump/lib/dump/client/dump';
+import {
+  creativeTabName,
+  dumpTextString,
+} from '@terrafirmagreg-team/dump/lib/dump/assets/lang/names';
+import { stackDisplayName } from '@terrafirmagreg-team/game/lib/entry/display';
+import {
+  loadClientRegistry,
+  loadClientRegistryOrder,
+  resolveClientStackDisplay,
+} from '@terrafirmagreg-team/dump/lib/dump/client/registry';
+import { loadClientTagMembers } from '@terrafirmagreg-team/dump/lib/dump/client/tags';
+import { loadClientTabs } from '@terrafirmagreg-team/dump/lib/dump/client/tabs';
+import { loadDatasetRecipeCategories } from '@terrafirmagreg-team/recipe/lib/data/category/load';
+import { loadClientRegistryGroups } from '@terrafirmagreg-team/dump/lib/dump/client/groups';
+import { loadClientModNames } from '@terrafirmagreg-team/dump/lib/dump/client/mods';
+import { loadClientModAtlases } from '@terrafirmagreg-team/dump/lib/dump/client/atlases';
+import { lookupSpriteInBundle } from '@terrafirmagreg-team/dump/lib/dump/assets/atlas/lookup';
+import { stackIdBase, stackIdFromRef } from '@terrafirmagreg-team/dump/lib/dump/contract/ref';
+import type { AtlasBundle } from '@terrafirmagreg-team/dump/lib/dump/assets/atlas/dto';
+import { createDatasetCache } from '@terrafirmagreg-team/dump/lib/dump/reader';
+
+async function clientEntityNames(
+  dataset: DatasetRef,
+  lang: string,
+  ids: Iterable<string>,
+): Promise<Record<string, string>> {
+  const [map, items, fluids] = await Promise.all([
+    clientDumpLang(dataset, lang),
+    loadClientRegistry(dataset, 'items'),
+    loadClientRegistry(dataset, 'fluids'),
+  ]);
+  const all = [...new Set([...items.keys(), ...fluids.keys(), ...ids])];
+  const info = new Map<string, { baseId: string; langKey?: string }>();
+  const mods = new Set<string>();
+  for (const id of all) {
+    const baseId = stackIdBase(id);
+    const langKey = resolveClientStackDisplay(id, items, fluids)?.name;
+    info.set(id, { baseId, ...(langKey ? { langKey } : {}) });
+    if (!langKey && baseId.includes(':') && !baseId.startsWith('#')) {
+      const mod = baseId.split(':', 2)[0];
+      if (mod) mods.add(mod);
+    }
+  }
+  const atlases = new Map<string, AtlasBundle>();
+  await Promise.all(
+    [...mods].map(async (mod) => {
+      atlases.set(mod, await loadClientModAtlases(dataset, mod));
+    }),
+  );
+  const names: Record<string, string> = { ...map };
+  let processed = 0;
+  for (const [id, entry] of info) {
+    if (++processed % 2000 === 0) {
+      await new Promise((resolve) => setTimeout(resolve));
+    }
+    const langKey =
+      entry.langKey ??
+      lookupSpriteInBundle(
+        atlases.get(entry.baseId.split(':', 2)[0] ?? ''),
+        entry.baseId,
+      )?.sprite.langKey;
+    const kind = entry.baseId.startsWith('#')
+      ? undefined
+      : fluids.has(entry.baseId)
+        ? 'fluid'
+        : 'item';
+    names[id] = stackDisplayName(map, id, kind, langKey);
+  }
+  return names;
+}
+
+async function clientNamedCategories(
+  dataset: DatasetRef,
+  lang: string,
+  types: string[],
+  categories: RecipeCategory[],
+): Promise<Record<string, string>> {
+  const map = await clientDumpLang(dataset, lang);
+  const byId = new Map(categories.map((row) => [row.id, row]));
+  const names: Record<string, string> = {};
+  for (const id of types) {
+    names[id] = creativeTabName(map, byId.get(id)?.display?.name ?? id);
+  }
+  return names;
+}
+
+async function clientUsedIds(dataset: DatasetRef): Promise<string[]> {
+  const manifest = await loadClientManifest(dataset);
+  return manifest?.indexes.used ?? [];
+}
+
+async function clientRecipeGroups(
+  dataset: DatasetRef,
+  lang: string,
+): Promise<RecipeStackGroup[]> {
+  const rows = await loadClientRegistryGroups(dataset);
+  if (!rows.length) return [];
+  const map = await clientDumpLang(dataset, lang);
+  return rows.map((row) => ({
+    id: row.id,
+    ...(row.name ? { name: dumpTextString(map, row.name) } : {}),
+    members: row.members,
+  }));
+}
+
+const loadChrome = createDatasetCache(
+  async (dataset: DatasetRef, lang: string): Promise<RecipeChrome> => {
+    const [items, fluids, creative, categories, usedIds, itemTags, blockTags] =
+      await Promise.all([
+        loadClientRegistryOrder(dataset, 'item'),
+        loadClientRegistryOrder(dataset, 'fluid'),
+        loadClientTabs(dataset),
+        loadDatasetRecipeCategories(dataset),
+        clientUsedIds(dataset),
+        loadClientTagMembers(dataset, 'item'),
+        loadClientTagMembers(dataset, 'block'),
+      ]);
+    const tabs = creative.tabs;
+    const tabItems = Object.keys(creative.members).length
+      ? creative.members
+      : undefined;
+    const types = categories.map((row) => row.id);
+    const tagIds = new Set([
+      ...Object.keys(itemTags ?? {}),
+      ...Object.keys(blockTags ?? {}),
+    ]);
+    const nameIds = [
+      ...items,
+      ...fluids,
+      ...tagIds,
+      ...(usedIds ?? []),
+      ...Object.values(tabItems ?? {}).flat(),
+      ...tabs.flatMap((tab) =>
+        tab.icon ? [stackIdFromRef(tab.icon)] : [],
+      ),
+    ];
+    const [groups, mods, entityNames, categoryNames, tabNames] =
+      await Promise.all([
+        clientRecipeGroups(dataset, lang),
+        loadClientModNames(dataset, lang),
+        clientEntityNames(dataset, lang, nameIds),
+        clientNamedCategories(dataset, lang, types, categories),
+        clientDumpLang(dataset, lang).then((map) => {
+          const names: Record<string, string> = {};
+          for (const tab of tabs) {
+            names[tab.id] = creativeTabName(map, tab.display.name ?? tab.id);
+          }
+          return names;
+        }),
+      ]);
+    return {
+      items,
+      ...(usedIds.length ? { usedIds } : {}),
+      ...(fluids.length ? { fluids } : {}),
+      ...(tabs.length ? { tabs } : {}),
+      ...(tabItems ? { tabItems } : {}),
+      ...(categories.length ? { categories } : {}),
+      ...(groups.length ? { groups } : {}),
+      mods,
+      names: {
+        [lang]: { ...tabNames, ...categoryNames, ...entityNames },
+      },
+    };
+  },
+);
+
+export function loadRecipeChromeClient(
+  dataset: DatasetRef,
+  lang: string,
+): Promise<RecipeChrome> {
+  return loadChrome(dataset, lang);
+}
+

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

@@ -0,0 +1,20 @@
+export {
+  loadAllTagMembers,
+  loadRegistryEntrySlice,
+  loadTagSlice,
+} from './registry';
+export { loadRecipeChromeClient } from './chrome';
+export {
+  loadCategoryRecipes,
+  loadTypeRows,
+  resolveRecipeRows,
+  TAG_RECIPE_TYPE,
+} from './rows';
+export { loadItemTooltips } from './tooltips';
+export {
+  loadRecipeCompactIndex,
+  loadRecipeSkeletonIndex,
+  nonEmptyCategoryIds,
+  recipeItemName,
+} from './catalog';
+