@terrafirmagreg-team/game 0.0.0-stage → 0.1.0

package/src/lib/dump/client/dump.ts

@@ -0,0 +1,188 @@
+import { parseDumpManifest } from '@terrafirmagreg-team/game/lib/dump/manifest/parse';
+import { dumpReader } from '@terrafirmagreg-team/game/lib/dump/reader';
+import { dumpRelPublicUrl, splitDumpId } from '@terrafirmagreg-team/game/lib/dump/paths';
+import { stackIdBase } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import { asRecord } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import {
+  modelPublicUrl,
+  texturePublicUrl,
+} from '@terrafirmagreg-team/game/lib/dump/assets/urls';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+import type { DumpManifest, NamespaceDisplay } from '@terrafirmagreg-team/game/lib/dump/manifest/dto';
+import type { ClientDumpMod, GuideBookRef } from '@terrafirmagreg-team/game/lib/dump/mods/dto';
+
+export type { ClientDumpMod, GuideBookRef };
+
+type ClientDump = {
+  manifest: DumpManifest;
+  mods: ClientDumpMod[];
+};
+
+function clientBook(
+  namespace: string,
+  name: string,
+  locales: string[],
+): GuideBookRef | null {
+  if (!name || name.includes('..') || name.includes('/')) return null;
+  const dir = `data/${namespace}/guides/${name}`;
+  return {
+    namespace,
+    modId: namespace,
+    bookPath: name,
+    bookId: `${namespace}:${name}`,
+    dir,
+    locales,
+  };
+}
+
+export const loadClientManifest = createAsyncCache(
+  async (dataset: string): Promise<DumpManifest | null> => {
+    const reader = await dumpReader(dataset);
+    return parseDumpManifest(await reader.getJson('manifest.json')) ?? null;
+  },
+);
+
+export type DatasetVersions = { latest?: string; versions: string[] };
+
+export const loadClientVersions = createAsyncCache(
+  async (dataset: string): Promise<DatasetVersions | null> => {
+    const reader = await dumpReader(dataset);
+    const raw = await reader.getJson('versions.json');
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const row = raw as Record<string, unknown>;
+    const versions = Array.isArray(row.versions)
+      ? row.versions.filter((v): v is string => typeof v === 'string')
+      : [];
+    if (!versions.length) return null;
+    return {
+      latest: typeof row.latest === 'string' ? row.latest : undefined,
+      versions,
+    };
+  },
+);
+
+export const loadClientDump = createAsyncCache(
+  async (dataset: string): Promise<ClientDump | null> => {
+    const manifest = await loadClientManifest(dataset);
+    if (!manifest) return null;
+    const mods = Object.entries(manifest.namespaces)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([namespace, listed]) => ({
+        namespace,
+        books: (listed?.guides ?? []).flatMap((name) => {
+          const book = clientBook(namespace, name, manifest.languages);
+          return book ? [book] : [];
+        }),
+      }));
+    return { manifest, mods };
+  },
+);
+
+export function clientDumpJson(
+  dataset: string,
+  rel: string | null | undefined,
+  priority?: 'high',
+): Promise<unknown | undefined> {
+  if (!rel) return Promise.resolve(undefined);
+  return dumpReader(dataset).then((reader) => reader.getJson(rel, priority));
+}
+
+export async function clientNamespaceEntries(
+  dataset: string,
+  rel: (namespace: string) => string,
+  include: (ns: NamespaceDisplay) => boolean,
+  priority?: 'high',
+  merged = true,
+): Promise<{ namespace: string; entries: Record<string, unknown> }[]> {
+  const mergedRows = merged
+    ? asRecord(await clientDumpJson(dataset, rel('meta'), priority))
+    : undefined;
+  if (mergedRows) return [{ namespace: 'meta', entries: mergedRows }];
+  const manifest = await loadClientManifest(dataset);
+  if (!manifest) return [];
+  const namespaces = Object.keys(manifest.namespaces)
+    .flatMap((ns) => {
+      const listed = manifest.namespaces[ns];
+      return listed && include(listed) ? [ns] : [];
+    })
+    .sort((a, b) => a.localeCompare(b));
+  const rows = await Promise.all(
+    namespaces.map(async (namespace) => ({
+      namespace,
+      entries: asRecord(await clientDumpJson(dataset, rel(namespace), priority)),
+    })),
+  );
+  return rows.flatMap((row) =>
+    row.entries ? [{ namespace: row.namespace, entries: row.entries }] : [],
+  );
+}
+
+export function clientDumpLang(
+  dataset: string,
+  lang: string,
+): Promise<Record<string, string>> {
+  return dumpReader(dataset).then((reader) => reader.getLang(lang));
+}
+
+export function clientDumpLangRaw(
+  dataset: string,
+  lang: string,
+): Promise<Record<string, string>> {
+  return dumpReader(dataset).then((reader) => reader.getLangRaw(lang));
+}
+
+export async function clientRegistryDataFileRel(
+  dataset: string,
+  ns: string,
+  file: string,
+): Promise<string | undefined> {
+  const manifest = await loadClientManifest(dataset);
+  const listed = manifest?.namespaces[ns];
+  if (!listed || !listed.registry.includes(file)) return undefined;
+  return `registry/${file}.json`;
+}
+
+function stackNs(id: string): string | undefined {
+  const ns = stackIdBase(id).split(':', 1)[0];
+  return ns || undefined;
+}
+
+export function clientTagFileRel(
+  dataset: string,
+  tagId: string,
+): Promise<string | undefined> {
+  const ns = stackNs(tagId.startsWith('#') ? tagId.slice(1) : tagId);
+  return ns
+    ? clientRegistryDataFileRel(dataset, ns, 'tags')
+    : Promise.resolve(undefined);
+}
+
+export function dumpTextureUrl(
+  dataset: string,
+  textureId: string,
+): string | undefined {
+  return texturePublicUrl(dataset, textureId);
+}
+
+export async function dumpModelUrl(
+  dataset: string,
+  modelId: string,
+): Promise<string | undefined> {
+  const parts = splitDumpId(modelId.trim());
+  if (!parts) return undefined;
+  const index = await clientDumpJson(
+    dataset,
+    `data/${parts.ns}/models/multiblock.json`,
+  );
+  const rel =
+    index && typeof index === 'object' && !Array.isArray(index)
+      ? (index as Record<string, unknown>)[modelId]
+      : undefined;
+  return modelPublicUrl(
+    dataset,
+    parts.ns,
+    typeof rel === 'string' ? rel : undefined,
+  );
+}
+
+export { dumpRelPublicUrl };

package/src/lib/dump/client/groups.ts

@@ -0,0 +1,31 @@
+import { asRecord, asStringList } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { asDumpText, type DumpText } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import { clientNamespaceEntries } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+type RegistryGroupRow = {
+  id: string;
+  name?: DumpText;
+  members: string[];
+};
+
+export const loadClientRegistryGroups = createAsyncCache(
+  async (dataset: string): Promise<RegistryGroupRow[]> => {
+    const out: RegistryGroupRow[] = [];
+    const files = await clientNamespaceEntries(
+      dataset,
+      () => 'registry/groups.json',
+      (ns) => ns.registry.includes('groups'),
+    );
+    for (const { entries } of files) {
+      for (const [id, raw] of Object.entries(entries)) {
+        const row = asRecord(raw);
+        const members = asStringList(row?.members);
+        if (!id || members.length <= 1) continue;
+        const name = asDumpText(row?.name);
+        out.push({ id, ...(name ? { name } : {}), members });
+      }
+    }
+    return out;
+  },
+);

package/src/lib/dump/client/keybinds.ts

@@ -0,0 +1,11 @@
+import { asStringMap } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { clientDumpJson } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+export const loadClientKeybinds = createAsyncCache(
+  async (dataset: string): Promise<Record<string, string>> => {
+    return (
+      asStringMap(await clientDumpJson(dataset, 'keybinds.json', 'high')) ?? {}
+    );
+  },
+);

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

@@ -0,0 +1,16 @@
+import { langString } from '@terrafirmagreg-team/game/lib/dump/assets/lang/names';
+import { clientDumpLang, loadClientManifest } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+export const loadClientModNames = createAsyncCache(
+  async (dataset: string, lang: string): Promise<Record<string, string>> => {
+    const manifest = await loadClientManifest(dataset);
+    const map = await clientDumpLang(dataset, lang);
+    const out: Record<string, string> = {};
+    for (const [ns, entry] of Object.entries(manifest?.namespaces ?? {})) {
+      const key = entry?.display?.name;
+      out[ns] = langString(map, key) ?? key ?? ns;
+    }
+    return out;
+  },
+);

package/src/lib/dump/client/registry.ts

@@ -0,0 +1,125 @@
+import { asIdTable, EDGE_TABLE_FIELD } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { asEntry, displayOf } from '@terrafirmagreg-team/game/lib/dump/data/registry/parse';
+import { parseStackId } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { DumpDisplay, DumpText } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import type {
+  DumpBlockEntry,
+  DumpEntityEntry,
+  DumpFluidEntry,
+  DumpItemEntry,
+  DumpRegistryEntry,
+  DumpRegistryKind,
+} from '@terrafirmagreg-team/game/lib/dump/data/registry/dto';
+import { clientNamespaceEntries } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+type RegistryByKind = {
+  items: DumpItemEntry;
+  blocks: DumpBlockEntry;
+  fluids: DumpFluidEntry;
+  entities: DumpEntityEntry;
+};
+
+const KIND_FILE: Record<DumpRegistryKind, string> = {
+  items: 'items',
+  blocks: 'blocks',
+  fluids: 'fluids',
+  entities: 'entities',
+};
+
+const clientRegistry = createAsyncCache(
+  async (
+    dataset: string,
+    kind: DumpRegistryKind,
+  ): Promise<Map<string, DumpRegistryEntry>> => {
+    const out = new Map<string, DumpRegistryEntry>();
+    const file = KIND_FILE[kind];
+    const files = await clientNamespaceEntries(
+      dataset,
+      () => `registry/${file}.json`,
+      (ns) => ns.registry.includes(file),
+    );
+    for (const { entries } of files) {
+      const ids = asIdTable(entries);
+      for (const [id, raw] of Object.entries(entries)) {
+        if (id === EDGE_TABLE_FIELD) continue;
+        const entry = asEntry(raw, kind, id, ids);
+        if (!entry) continue;
+        if (!out.has(id)) out.set(id, entry);
+        if (entry.id !== id && !out.has(entry.id)) {
+          out.set(entry.id, entry);
+        }
+      }
+    }
+    return out;
+  },
+);
+
+export function loadClientRegistry<K extends DumpRegistryKind>(
+  dataset: string,
+  kind: K,
+): Promise<Map<string, RegistryByKind[K]>> {
+  return clientRegistry(dataset, kind) as Promise<Map<string, RegistryByKind[K]>>;
+}
+
+export function resolveClientStackDisplay(
+  compactId: string,
+  items: Map<string, DumpItemEntry>,
+  fluids: Map<string, DumpFluidEntry>,
+): DumpDisplay | undefined {
+  const parsed = parseStackId(compactId);
+  const item = items.get(parsed.id);
+  if (item) return displayOf(item, parsed.nbt);
+  const fluid = fluids.get(parsed.id);
+  if (fluid) return displayOf(fluid, parsed.nbt);
+  return undefined;
+}
+
+const SINGULAR_KIND: Record<string, DumpRegistryKind> = {
+  item: 'items',
+  block: 'blocks',
+  fluid: 'fluids',
+  entity: 'entities',
+};
+
+export function clientRegistryKindFor(kind: string): DumpRegistryKind {
+  return SINGULAR_KIND[kind] ?? (kind as DumpRegistryKind);
+}
+
+export async function loadClientRegistryOrder(
+  dataset: string,
+  kind: string,
+): Promise<string[]> {
+  const entries = await loadClientRegistry(dataset, clientRegistryKindFor(kind));
+  return [...entries.values()]
+    .flatMap((entry) => (entry.order != null ? [entry] : []))
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id))
+    .map((entry) => entry.id);
+}
+
+export async function loadClientRegistryTooltips(
+  dataset: string,
+  kind: string,
+): Promise<Record<string, DumpText[]> | undefined> {
+  const entries = await loadClientRegistry(dataset, clientRegistryKindFor(kind));
+  const out: Record<string, DumpText[]> = {};
+  for (const entry of entries.values()) {
+    const tooltip = entry.display?.tooltip;
+    if (tooltip?.length) out[entry.id] = tooltip;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+export async function loadClientRegistryTooltipsMod(
+  dataset: string,
+  kind: string,
+  mod: string,
+): Promise<Record<string, DumpText[]> | undefined> {
+  const entries = await loadClientRegistry(dataset, clientRegistryKindFor(kind));
+  const out: Record<string, DumpText[]> = {};
+  for (const entry of entries.values()) {
+    const lines = entry.display?.tooltipMods?.[mod];
+    if (lines?.length) out[entry.id] = lines;
+  }
+  return Object.keys(out).length ? out : undefined;
+}

package/src/lib/dump/client/tabs.ts

@@ -0,0 +1,27 @@
+import { asTab, asTabItems } from '@terrafirmagreg-team/game/lib/dump/data/tab/parse';
+import type { DumpCreativeTab, DumpCreativeTabs } from '@terrafirmagreg-team/game/lib/dump/data/tab/dto';
+import { clientNamespaceEntries } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+export const loadClientTabs = createAsyncCache(
+  async (dataset: string): Promise<DumpCreativeTabs> => {
+    const tabs: DumpCreativeTab[] = [];
+    const members: Record<string, string[]> = {};
+    const files = await clientNamespaceEntries(
+      dataset,
+      () => 'registry/tabs.json',
+      (ns) => ns.registry.includes('tabs'),
+    );
+    for (const { entries } of files) {
+      for (const raw of Object.values(entries)) {
+        const tab = asTab(raw);
+        if (!tab) continue;
+        tabs.push(tab);
+        const items = asTabItems(raw);
+        if (items.length) members[tab.id] = items;
+      }
+    }
+    tabs.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+    return { tabs, members };
+  },
+);

package/src/lib/dump/client/tags.ts

@@ -0,0 +1,64 @@
+import { asIdTable, EDGE_TABLE_FIELD } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { asTag } from '@terrafirmagreg-team/game/lib/dump/data/tag/parse';
+import type { DumpTag } from '@terrafirmagreg-team/game/lib/dump/data/tag/dto';
+import { clientNamespaceEntries } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { tagHashId, tagIdForms } from '@terrafirmagreg-team/game/lib/dump/paths';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+function indexKeys(tag: DumpTag, manifestKey: string): string[] {
+  return [...new Set([manifestKey, ...tagIdForms(tag.id)])];
+}
+
+const loadClientTags = createAsyncCache(async (dataset: string) => {
+  const map = new Map<string, DumpTag>();
+  const files = await clientNamespaceEntries(
+    dataset,
+    () => 'registry/tags.json',
+    (ns) => ns.registry.includes('tags'),
+  );
+  for (const { entries } of files) {
+    const ids = asIdTable(entries);
+    for (const [manifestKey, raw] of Object.entries(entries)) {
+      if (manifestKey === EDGE_TABLE_FIELD) continue;
+      const tag = asTag(raw, manifestKey, ids);
+      if (!tag) continue;
+      for (const alias of indexKeys(tag, manifestKey)) {
+        if (!map.has(alias)) map.set(alias, tag);
+      }
+    }
+  }
+  return map;
+});
+
+export async function resolveClientTag(
+  dataset: string,
+  id: string,
+): Promise<DumpTag | undefined> {
+  const tags = await loadClientTags(dataset);
+  for (const form of tagIdForms(id)) {
+    const hit = tags.get(form);
+    if (hit) return hit;
+  }
+  return undefined;
+}
+
+const MEMBER_REGISTRY: Record<string, string> = {
+  item: 'items',
+  block: 'blocks',
+  fluid: 'fluids',
+  entity: 'entities',
+};
+
+export async function loadClientTagMembers(
+  dataset: string,
+  kind: string,
+): Promise<Record<string, string[]> | undefined> {
+  const registry = MEMBER_REGISTRY[kind] ?? kind;
+  const out: Record<string, string[]> = {};
+  for (const tag of (await loadClientTags(dataset)).values()) {
+    if (tag.registry !== registry || !tag.members.length) continue;
+    out[tagHashId(tag.id)] ??= tag.members;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+

package/src/lib/dump/contract/kind.ts

@@ -0,0 +1,61 @@
+import {
+  asTaggedReference,
+  stackIdFromRef,
+  type ReferenceKind,
+  type TaggedReference,
+} from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import { asRecord, asString } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+
+const LINK_KINDS = [
+  'item',
+  'block',
+  'fluid',
+  'entity',
+  'tag',
+  'texture',
+  'recipe',
+  'quest',
+  'guide',
+] as const;
+
+export type ResourceKind = (typeof LINK_KINDS)[number];
+
+export function asResourceKind(value: unknown): ResourceKind | undefined {
+  return typeof value === 'string' &&
+    (LINK_KINDS as readonly string[]).includes(value)
+    ? (value as ResourceKind)
+    : undefined;
+}
+
+export function referenceKindFromResource(
+  kind: ResourceKind | undefined,
+): ReferenceKind | undefined {
+  switch (kind) {
+    case 'tag':
+      return 'itemTag';
+    case 'item':
+    case 'block':
+    case 'fluid':
+    case 'entity':
+    case 'texture':
+    case 'recipe':
+    case 'quest':
+    case 'guide':
+      return kind;
+    default:
+      return undefined;
+  }
+}
+
+export function referenceFrom(value: unknown): TaggedReference | undefined {
+  const tagged = asTaggedReference(value);
+  if (tagged) return { kind: tagged.kind, id: stackIdFromRef(tagged) };
+  const row = asRecord(value);
+  const tagId = asString(row?.tag);
+  if (tagId && row?.id === undefined && row?.kind === undefined) {
+    return { kind: 'itemTag', id: `#${tagId}` };
+  }
+  const kind = referenceKindFromResource(asResourceKind(row?.kind));
+  const id = asString(row?.id);
+  return kind && id ? { kind, id } : undefined;
+}

package/src/lib/dump/contract/read.ts

@@ -0,0 +1,77 @@
+
+
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+export function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+export function asNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+export function asBool(value: unknown): boolean | undefined {
+  if (typeof value === 'boolean') return value;
+  if (value === 1) return true;
+  if (value === 0) return false;
+  return undefined;
+}
+
+export function asStringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === 'string' && Boolean(item));
+}
+
+export const EDGE_TABLE_FIELD = '$ids';
+
+export function asIdTable(file: unknown): string[] | undefined {
+  const ids = asStringList(asRecord(file)?.[EDGE_TABLE_FIELD]);
+  return ids.length ? ids : undefined;
+}
+
+export function asEdgeList(value: unknown, ids?: string[]): string[] {
+  if (!Array.isArray(value)) return [];
+  const out: string[] = [];
+  for (const item of value) {
+    if (typeof item === 'string') {
+      if (item) out.push(item);
+      continue;
+    }
+    if (typeof item === 'number' && Number.isInteger(item)) {
+      const ref = ids?.[item];
+      if (ref) out.push(ref);
+    }
+  }
+  return out;
+}
+
+export function resolveEdgeRows(
+  map: Record<string, unknown>,
+): Record<string, Record<string, unknown>> {
+  const ids = asIdTable(map);
+  const out: Record<string, Record<string, unknown>> = {};
+  for (const [key, value] of Object.entries(map)) {
+    if (key === EDGE_TABLE_FIELD) continue;
+    const row = asRecord(value);
+    if (!row) continue;
+    if (ids) {
+      if (Array.isArray(row.usedBy)) row.usedBy = asEdgeList(row.usedBy, ids);
+      if (Array.isArray(row.producedBy)) row.producedBy = asEdgeList(row.producedBy, ids);
+    }
+    out[key] = row;
+  }
+  return out;
+}
+
+export function asStringMap(value: unknown): Record<string, string> | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const out: Record<string, string> = {};
+  for (const [key, item] of Object.entries(row)) {
+    if (typeof item === 'string') out[key] = item;
+  }
+  return out;
+}