@terrafirmagreg-team/game 0.0.0-stage → 0.1.0

package/src/lib/dump/mods/index.ts

@@ -0,0 +1,81 @@
+import type {
+  DumpManifest,
+  NamespaceDisplay,
+} from '@terrafirmagreg-team/game/lib/dump/manifest/dto';
+import type { DumpIndex, DumpMod, GuideBookRef } from '@terrafirmagreg-team/game/lib/dump/mods/dto';
+
+function registryRel(
+  meta: NamespaceDisplay,
+  file: string,
+): string | null {
+  return meta.registry.includes(file) ? `registry/${file}.json` : null;
+}
+
+function loadBooks(
+  namespace: string,
+  guides: string[],
+  locales: string[],
+): { guides: Record<string, string>; books: GuideBookRef[] } {
+  const out: { guides: Record<string, string>; books: GuideBookRef[] } = {
+    guides: {},
+    books: [],
+  };
+  for (const name of guides) {
+    if (!name || name.includes('..') || name.includes('/')) continue;
+    const bookId = `${namespace}:${name}`;
+    const dir = `data/${namespace}/guides/${name}`;
+    out.guides[bookId] = dir;
+    out.books.push({
+      namespace,
+      modId: namespace,
+      bookPath: name,
+      bookId,
+      dir,
+      locales,
+    });
+  }
+  return out;
+}
+
+function loadMod(
+  namespace: string,
+  meta: NamespaceDisplay,
+  manifest: DumpManifest,
+): DumpMod {
+  const dumpLangs = new Set(manifest.languages);
+  const languages: Record<string, string> = {};
+  for (const code of meta.languages) {
+    if (!dumpLangs.has(code)) continue;
+    languages[code] = `lang/${code}.json`;
+  }
+  return {
+    namespace,
+    languages,
+    keybindsFile: meta.keybinds ? 'keybinds.json' : null,
+    items: registryRel(meta, 'items'),
+    blocks: registryRel(meta, 'blocks'),
+    fluids: registryRel(meta, 'fluids'),
+    entities: registryRel(meta, 'entities'),
+    tabs: registryRel(meta, 'tabs'),
+    groups: registryRel(meta, 'groups'),
+    recipeCategories: registryRel(meta, 'recipe_categories'),
+    tags: registryRel(meta, 'tags'),
+    recipeIndex: registryRel(meta, 'recipes'),
+    modelIndex: null,
+    questData: meta.quests ? `data/${namespace}/quests/data.json` : null,
+    ...loadBooks(namespace, meta.guides, manifest.languages),
+  };
+}
+
+export function dumpIndexFromManifest(
+  manifest: DumpManifest,
+  root: string,
+): DumpIndex {
+  const mods = Object.keys(manifest.namespaces)
+    .sort((a, b) => a.localeCompare(b))
+    .flatMap((namespace) => {
+      const row = manifest.namespaces[namespace];
+      return row ? [loadMod(namespace, row, manifest)] : [];
+    });
+  return { root, manifest, mods };
+}

package/src/lib/dump/mods/load.ts

@@ -0,0 +1,61 @@
+import 'server-only';
+import { asRecord, asString } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { dumpLocation } from '@terrafirmagreg-team/game/lib/dump/paths';
+import { dumpReader } from '@terrafirmagreg-team/game/lib/dump/reader';
+import { parseDumpManifest } from '@terrafirmagreg-team/game/lib/dump/manifest/parse';
+import { parseDatasetRef } from '@terrafirmagreg-team/kit/lib/location';
+import { sectionConfig } from '@terrafirmagreg-team/kit/lib/config';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+import { dumpIndexFromManifest } from '@terrafirmagreg-team/game/lib/dump/mods/index';
+import type { DumpIndex } from '@terrafirmagreg-team/game/lib/dump/mods/dto';
+
+const dumpCache = createAsyncCache(
+  async (dataset: string): Promise<DumpIndex | null> => {
+    const reader = await dumpReader(dataset);
+    const manifest = parseDumpManifest(await reader.getJson('manifest.json'));
+    if (!manifest) return null;
+    return dumpIndexFromManifest(
+      manifest,
+      dumpLocation(dataset)?.root ?? parseDatasetRef(dataset).id,
+    );
+  },
+);
+
+export function loadDatasetDump(
+  dataset: string,
+): Promise<DumpIndex | null> {
+  return dumpCache(dataset);
+}
+
+export async function discoverDumpDatasets(): Promise<string[]> {
+  const refs = await Promise.all(
+    Object.keys(sectionConfig().datasetConfig).map(async (id) => {
+      const versions = asRecord(
+        await dumpReader(id).then((reader) =>
+          reader.getJson('versions.json'),
+        ),
+      );
+      const latest = asString(versions?.latest);
+      if (!versions || !latest) return [];
+      const manifest = await dumpReader(id).then((reader) =>
+        reader.getJson('manifest.json'),
+      );
+      if (!manifest) return [];
+      const listed = Array.isArray(versions.versions)
+        ? versions.versions.filter(
+            (row): row is string => typeof row === 'string',
+          )
+        : [];
+      const published = await Promise.all(
+        listed.map(async (version) => {
+          const ok = await dumpReader(`${id}@${version}`).then((reader) =>
+            reader.getJson('manifest.json'),
+          );
+          return ok ? `${id}@${version}` : null;
+        }),
+      );
+      return [id, ...published.filter((row): row is string => row !== null)];
+    }),
+  );
+  return refs.flat().sort();
+}

package/src/lib/dump/paths.ts

@@ -0,0 +1,171 @@
+
+
+import { stackIdBase } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+
+export type DumpLocation = {
+
+  root: string;
+
+  files?: Record<string, string>;
+};
+
+const dumpLocations = new Map<string, DumpLocation>();
+const dumpLocationListeners = new Set<() => void>();
+
+export function registerDumpLocation(
+  dataset: string,
+  location: DumpLocation,
+): void {
+  dumpLocations.set(dataset, location);
+  for (const listener of dumpLocationListeners) listener();
+}
+
+export function subscribeDumpLocations(listener: () => void): () => void {
+  dumpLocationListeners.add(listener);
+  return () => dumpLocationListeners.delete(listener);
+}
+
+export function dumpLocation(dataset: string): DumpLocation | undefined {
+  return dumpLocations.get(dataset);
+}
+
+export function dumpStorageUrl(storageRel: string): string {
+  const origin = (process.env.NEXT_PUBLIC_DUMP_STORAGE_URL ?? '').replace(
+    /\/+$/,
+    '',
+  );
+  if (!origin) {
+    throw new Error(
+      'NEXT_PUBLIC_DUMP_STORAGE_URL is not set — dump storage is required.',
+    );
+  }
+  return `${origin}/${storageRel}`;
+}
+
+export function dumpPublicUrl(
+  dataset: string,
+  ...segments: string[]
+): string | undefined {
+  const ds = cleanDumpSegment(dataset);
+  if (!ds || ds.includes('/')) {
+    throw new Error(`Invalid dump dataset segment: ${dataset}`);
+  }
+  const rel = segments
+    .map(cleanDumpSegment)
+    .filter((s): s is string => Boolean(s))
+    .join('/');
+  const loc = dumpLocation(dataset);
+  if (!loc) return undefined;
+  const key = rel ? loc.files?.[rel] : undefined;
+  const storageRel = key ?? `${loc.root}${rel ? `/${rel}` : ''}`;
+  return dumpStorageUrl(storageRel);
+}
+
+function cleanDumpSegment(segment: string): string | null {
+  const cleaned = segment.replaceAll('\\', '/').replace(/^\/+/, '');
+  if (!cleaned || cleaned.includes('..')) return null;
+  return cleaned;
+}
+
+export function cleanDumpRel(rel: string): string | null {
+  return cleanDumpSegment(rel);
+}
+
+function dumpDirOf(rel: string): string {
+  const cleaned = cleanDumpRel(rel) ?? '';
+  const slash = cleaned.lastIndexOf('/');
+  return slash >= 0 ? cleaned.slice(0, slash) : '';
+}
+
+export function joinDumpRel(
+  baseFileRel: string,
+  childRel: string,
+): string | null {
+  const child = cleanDumpRel(childRel);
+  if (!child) return null;
+  const dir = dumpDirOf(baseFileRel);
+  return dir ? `${dir}/${child}` : child;
+}
+
+const TAG_REGISTRIES = ['items', 'blocks', 'fluids', 'entities'] as const;
+
+export function tagHashId(tagId: string): string {
+  return `#${tagId.replace(/^#+/, '')}`;
+}
+
+export function tagIdForms(tagId: string): string[] {
+  const raw = tagId.startsWith('#') ? tagId.slice(1) : tagId;
+  return [raw, `#${raw}`];
+}
+
+function tagRegistryKeys(
+  tagId: string,
+  preferredRegistry?: string,
+): string[] {
+  const raw = tagId.startsWith('#') ? tagId.slice(1) : tagId;
+  const parts = splitDumpId(raw);
+  if (!parts) return [];
+  const registries = preferredRegistry
+    ? [
+        preferredRegistry,
+        ...TAG_REGISTRIES.filter((registry) => registry !== preferredRegistry),
+      ]
+    : TAG_REGISTRIES;
+  return registries.map((registry) => `${parts.ns}:${registry}/${parts.path}`);
+}
+
+export function matchTagIndexKey(
+  entries: Record<string, unknown> | undefined,
+  tagId: string,
+  preferredRegistry?: string,
+): string | undefined {
+  if (!entries) return undefined;
+  for (const form of tagIdForms(tagId)) {
+    if (entries[form] !== undefined) return form;
+  }
+  for (const key of tagRegistryKeys(tagId, preferredRegistry)) {
+    if (entries[key] !== undefined) return key;
+  }
+  const raw = tagId.startsWith('#') ? tagId.slice(1) : tagId;
+  const parts = splitDumpId(raw);
+  if (!parts) return undefined;
+  const candidates = Object.keys(entries).filter(
+    (key) => key.startsWith(`${parts.ns}:`) && key.endsWith(`/${parts.path}`),
+  );
+  return candidates.sort()[0];
+}
+
+export function splitDumpId(
+  id: string,
+): { ns: string; path: string } | undefined {
+  const sep = id.indexOf(':');
+  if (sep < 1) return undefined;
+  const ns = id.slice(0, sep);
+  const path = id
+    .slice(sep + 1)
+    .replaceAll('\\', '/')
+    .replace(/\/{2,}/g, '/')
+    .replace(/^\/+|\/+$/g, '');
+  if (!ns || !path || ns.includes('/') || ns.includes('..') || path.includes('..')) {
+    return undefined;
+  }
+  return { ns, path };
+}
+
+export function registryId(id: string): string {
+  return stackIdBase(id);
+}
+
+export function tagPseudoId(tag: string, kind?: string): string {
+  const raw = tagIdForms(tag)[0]!;
+  const parts = splitDumpId(raw);
+  return `emi:tag/${kind ?? 'item'}/${parts ? `${parts.ns}/${parts.path}` : raw}`;
+}
+
+export function dumpRelPublicUrl(
+  dataset: string,
+  rel: string | null | undefined,
+): string | undefined {
+  const cleaned = typeof rel === 'string' ? cleanDumpRel(rel) : null;
+  return cleaned ? dumpPublicUrl(dataset, cleaned) : undefined;
+}

package/src/lib/dump/reader.ts

@@ -0,0 +1,15 @@
+import { JsonDumpReader } from '@terrafirmagreg-team/game/lib/dump/json-reader';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+export interface DumpReader {
+
+  getJson(path: string, priority?: 'high'): Promise<unknown | undefined>;
+
+  getLang(lang: string): Promise<Record<string, string>>;
+
+  getLangRaw(lang: string): Promise<Record<string, string>>;
+}
+
+export const dumpReader = createAsyncCache(
+  async (dataset: string): Promise<DumpReader> => new JsonDumpReader(dataset),
+);

package/src/lib/entry/display.ts

@@ -0,0 +1,4 @@
+export {
+  stackDisplay,
+  stackDisplayName,
+} from '@terrafirmagreg-team/game/lib/dump/assets/lang/names';

package/src/lib/entry/entry.ts

@@ -0,0 +1,57 @@
+import { entryHref } from '@terrafirmagreg-team/game/lib/entry/href';
+import { tagKindOf } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { ReferenceKind } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { EntryProps } from '@terrafirmagreg-team/game/types/entry';
+
+export function usesStackTooltip(kind: ReferenceKind | undefined): boolean {
+  switch (kind) {
+    case 'texture':
+    case 'model':
+    case 'recipe':
+    case 'quest':
+    case 'guide':
+    case 'chapter':
+      return false;
+    default:
+      return true;
+  }
+}
+
+export function tooltipLoadKind(
+  kind: ReferenceKind | undefined,
+): 'item' | 'fluid' | 'entity' | undefined {
+  const member = tagKindOf(kind) ?? kind;
+  if (member === 'fluid') return 'fluid';
+  if (member === 'entity') return 'entity';
+  return 'item';
+}
+
+export function resolveEntryHref(
+  props: EntryProps & { dataset: string },
+): string | undefined {
+  if (props.href === false) return undefined;
+  if (typeof props.href === 'string') return props.href;
+  if (!props.lang) return undefined;
+  const kind = props.reference?.kind ?? props.kind ?? 'item';
+  const id = props.reference?.id ?? props.id;
+  if (!id) return undefined;
+  if (kind === 'entity' || kind === 'texture' || kind === 'model') {
+    return undefined;
+  }
+  return entryHref(
+    props.dataset,
+    props.lang,
+    props.reference ?? { kind, id, ...(props.tag !== undefined ? { tag: props.tag } : {}) },
+    {
+      tab: props.tab,
+      type: props.type,
+      search: props.search,
+      rpage: props.rpage,
+      filename: props.filename,
+      modId: props.modId,
+      bookPath: props.bookPath,
+      entry: props.entry,
+      hash: props.hash,
+    },
+  );
+}

package/src/lib/entry/formula.ts

@@ -0,0 +1,226 @@
+const ELEMENT_COLORS: Record<string, string> = {
+  H: '#FFFFFF',
+  D: '#FFFFC0',
+  T: '#FFFFA0',
+  He: '#D9FFFF',
+  Li: '#CC80FF',
+  Be: '#C2FF00',
+  B: '#FFB5B5',
+  C: '#909090',
+  N: '#3050F8',
+  O: '#FF0D0D',
+  F: '#90E050',
+  Ne: '#B3E3F5',
+  Na: '#AB5CF2',
+  Mg: '#8AFF00',
+  Al: '#BFA6A6',
+  Si: '#F0C8A0',
+  P: '#FF8000',
+  S: '#FFFF30',
+  Cl: '#1FF01F',
+  Ar: '#80D1E3',
+  K: '#8F40D4',
+  Ca: '#3DFF00',
+  Sc: '#E6E6E6',
+  Ti: '#BFC2C7',
+  V: '#A6A6AB',
+  Cr: '#8A99C7',
+  Mn: '#9C7AC7',
+  Fe: '#E06633',
+  Co: '#F090A0',
+  Ni: '#50D050',
+  Cu: '#C88033',
+  Zn: '#7D80B0',
+  Ga: '#C28F8F',
+  Ge: '#668F8F',
+  As: '#BD80E3',
+  Se: '#FFA100',
+  Br: '#A62929',
+  Kr: '#5CB8D1',
+  Rb: '#702EB0',
+  Sr: '#00FF00',
+  Y: '#94FFFF',
+  Zr: '#94E0E0',
+  Nb: '#73C2C9',
+  Mo: '#54B5B5',
+  Tc: '#3B9E9E',
+  Ru: '#248F8F',
+  Rh: '#0A7D8C',
+  Pd: '#000000',
+  Ag: '#C0C0C0',
+  Cd: '#FFD98F',
+  In: '#A67573',
+  Sn: '#668080',
+  Sb: '#9E63B5',
+  Te: '#D47A00',
+  I: '#940094',
+  Xe: '#429EB0',
+  Cs: '#57178F',
+  Ba: '#00C900',
+  La: '#70D4FF',
+  Ce: '#FFFFC7',
+  Pr: '#D9FFC7',
+  Nd: '#C7FFC7',
+  Pm: '#A3FFC7',
+  Sm: '#8FFFC7',
+  Eu: '#61FFC7',
+  Gd: '#45FFC7',
+  Tb: '#30FFC7',
+  Dy: '#1FFFC7',
+  Ho: '#00FF9C',
+  Er: '#00E675',
+  Tm: '#00D452',
+  Yb: '#00BF38',
+  Lu: '#00AB24',
+  Hf: '#4DC2FF',
+  Ta: '#4DA6FF',
+  W: '#2194D6',
+  Re: '#267DAB',
+  Os: '#266696',
+  Ir: '#175487',
+  Pt: '#D0D0E0',
+  Au: '#FFD123',
+  Hg: '#B8B8D0',
+  Tl: '#A6544D',
+  Pb: '#575961',
+  Bi: '#9E4FB5',
+  Po: '#AB5C00',
+  At: '#754F45',
+  Rn: '#428296',
+  Fr: '#420066',
+  Ra: '#000000',
+  Ac: '#70ABFA',
+  Th: '#00BAFF',
+  Pa: '#00A1FF',
+  U: '#008FFF',
+  Np: '#0080FF',
+  Pu: '#000000',
+  Am: '#545CF2',
+  Cm: '#785CE3',
+  Bk: '#8A4FE3',
+  Cf: '#A136D4',
+  Es: '#B31FD4',
+  Fm: '#B31FBA',
+  Md: '#B30DA6',
+  No: '#BD0D87',
+  Lr: '#C70066',
+  Rf: '#CC0059',
+  Db: '#D1004F',
+  Sg: '#D90045',
+  Bh: '#E00038',
+  Hs: '#E6002E',
+  Mt: '#EB0026',
+  Ds: '#EB0026',
+  Rg: '#FFFF55',
+  Cn: '#FFFF55',
+  Nh: '#FFFF55',
+  Fl: '#FFFF55',
+  Mc: '#FFFF55',
+  Lv: '#FFFF55',
+  Ts: '#FFFF55',
+  Og: '#FFFF55',
+  Nq: '#FFFF55',
+  Ke: '#FFFF55',
+  Tr: '#FFFF55',
+  Dr: '#FFFF55',
+  Nt: '#FFFF55',
+};
+
+const MIN_BRIGHTNESS = 0.1;
+
+function lightenHex(hex: string): string {
+  const value = Number.parseInt(hex.slice(1), 16);
+  const r = (value >> 16) & 0xff;
+  const g = (value >> 8) & 0xff;
+  const b = value & 0xff;
+  const max = Math.max(r, g, b) / 255;
+  const min = Math.min(r, g, b) / 255;
+  const delta = max - min;
+  let h = 0;
+  if (delta !== 0) {
+    if (max === r / 255) h = ((g / 255 - b / 255) / delta) % 6;
+    else if (max === g / 255) h = (b / 255 - r / 255) / delta + 2;
+    else h = (r / 255 - g / 255) / delta + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  const s = max === 0 ? 0 : delta / max;
+  const v = Math.max(max, MIN_BRIGHTNESS);
+  const c = v * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = v - c;
+  const [rp, gp, bp] =
+    h < 60
+      ? [c, x, 0]
+      : h < 120
+        ? [x, c, 0]
+        : h < 180
+          ? [0, c, x]
+          : h < 240
+            ? [0, x, c]
+            : h < 300
+              ? [x, 0, c]
+              : [c, 0, x];
+  const to255 = (n: number) =>
+    Math.round((n + m) * 255)
+      .toString(16)
+      .padStart(2, '0');
+  return `#${to255(rp)}${to255(gp)}${to255(bp)}`;
+}
+
+const LIGHTENED = new Map<string, string>();
+function elementColor(symbol: string): string | undefined {
+  const raw = ELEMENT_COLORS[symbol];
+  if (!raw) return undefined;
+  const cached = LIGHTENED.get(symbol);
+  if (cached) return cached;
+  const color = lightenHex(raw);
+  LIGHTENED.set(symbol, color);
+  return color;
+}
+
+const SUBSCRIPT = '₀₁₂₃₄₅₆₇₈₉';
+const SUPERSCRIPT = '⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻';
+const PUNCT = new Set('()[]{}·∙.*+?=-‐‑‒–—~≈≡,');
+
+export type FormulaRun = { text: string; color?: string };
+
+export function formulaRuns(plain: string): FormulaRun[] | null {
+  if (!plain || plain.length < 2) return null;
+  const runs: FormulaRun[] = [];
+  let i = 0;
+  let elements = 0;
+  let pushPlain = (text: string) => {
+    const last = runs[runs.length - 1];
+    if (last && !last.color) last.text += text;
+    else runs.push({ text });
+  };
+  while (i < plain.length) {
+    const ch = plain[i];
+    if (ch >= 'A' && ch <= 'Z') {
+      const two = plain.slice(i, i + 2);
+      const symbol = /^[a-z]$/.test(plain[i + 1] ?? '') ? two : ch;
+      const color = elementColor(symbol);
+      if (!color) return null;
+      runs.push({ text: symbol, color });
+      elements += 1;
+      i += symbol.length;
+      continue;
+    }
+    if ((ch >= '0' && ch <= '9') || SUBSCRIPT.includes(ch)) {
+      let j = i;
+      while (j < plain.length && /[0-9]/.test(plain[j])) j += 1;
+      while (j < plain.length && SUBSCRIPT.includes(plain[j])) j += 1;
+      pushPlain(plain.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (SUPERSCRIPT.includes(ch) || PUNCT.has(ch)) {
+      pushPlain(ch);
+      i += 1;
+      continue;
+    }
+    return null;
+  }
+  return elements > 0 ? runs : null;
+}