@terrafirmagreg-team/game 0.0.0-stage → 0.1.0

package/src/lib/dump/gen/registry/fluids.ts

@@ -0,0 +1,48 @@
+export interface RegistryFluids {
+  [k: string]: FluidEntry | undefined;
+}
+export interface FluidEntry {
+  display: Display;
+  id: string;
+  order?: number | null;
+  producedBy?: string[];
+  sprite?: null | SpriteEntry;
+  tags?: string[];
+  usedBy?: string[];
+  variants: VariantEntry[];
+}
+export interface Display {
+  name: string;
+  tooltip: DumpText[];
+  tooltipMods: {
+    [k: string]: DumpText[] | undefined;
+  };
+}
+export interface DumpText {
+  extra?: DumpText[];
+  keybind?: string;
+  text?: string;
+  translate?: string;
+  with?: DumpText[];
+}
+export interface SpriteEntry {
+  h: number;
+  image: string;
+  ph: number;
+  pw: number;
+  tint?: string | null;
+  tintColor?: string | null;
+  w: number;
+  x: number;
+  y: number;
+}
+export interface VariantEntry {
+  display?: null | Display;
+  model?: string | null;
+  sprite?: null | SpriteEntry;
+  tag?: null | JsonNode;
+  texture?: string | null;
+}
+export interface JsonNode {
+  [k: string]: unknown | undefined;
+}

package/src/lib/dump/gen/registry/groups.ts

@@ -0,0 +1,14 @@
+export interface RegistryGroups {
+  [k: string]: StackGroupValue | undefined;
+}
+export interface StackGroupValue {
+  members: string[];
+  name?: null | DumpText;
+}
+export interface DumpText {
+  extra?: DumpText[];
+  keybind?: string;
+  text?: string;
+  translate?: string;
+  with?: DumpText[];
+}

package/src/lib/dump/gen/registry/items.ts

@@ -0,0 +1,51 @@
+export interface RegistryItems {
+  [k: string]: ItemEntry | undefined;
+}
+export interface ItemEntry {
+  block?: string | null;
+  display: Display;
+  id: string;
+  maxCount?: number | null;
+  order?: number | null;
+  producedBy?: string[];
+  rarity?: string | null;
+  sprite?: null | SpriteEntry;
+  tags?: string[];
+  usedBy?: string[];
+  variants: VariantEntry[];
+}
+export interface Display {
+  name: string;
+  tooltip: DumpText[];
+  tooltipMods: {
+    [k: string]: DumpText[] | undefined;
+  };
+}
+export interface DumpText {
+  extra?: DumpText[];
+  keybind?: string;
+  text?: string;
+  translate?: string;
+  with?: DumpText[];
+}
+export interface SpriteEntry {
+  h: number;
+  image: string;
+  ph: number;
+  pw: number;
+  tint?: string | null;
+  tintColor?: string | null;
+  w: number;
+  x: number;
+  y: number;
+}
+export interface VariantEntry {
+  display?: null | Display;
+  model?: string | null;
+  sprite?: null | SpriteEntry;
+  tag?: null | JsonNode;
+  texture?: string | null;
+}
+export interface JsonNode {
+  [k: string]: unknown | undefined;
+}

package/src/lib/dump/gen/registry/recipe_categories.ts

@@ -0,0 +1,64 @@
+export type ResourceId = string;
+export type ReferenceKind =
+  | "item"
+  | "block"
+  | "fluid"
+  | "entity"
+  | "itemTag"
+  | "blockTag"
+  | "fluidTag"
+  | "entityTag"
+  | "texture"
+  | "model"
+  | "recipe";
+
+export interface RegistryRecipeCategories {
+  [k: string]: RecipeCategory | undefined;
+}
+export interface RecipeCategory {
+  display: Display;
+  icon?: null | TaggedReference;
+  layout?: null | RecipeCategoryLayout;
+  order: number;
+  workstations?: TaggedReference[];
+}
+export interface Display {
+  name: string;
+  tooltip: DumpText[];
+  tooltipMods: {
+    [k: string]: DumpText[] | undefined;
+  };
+}
+export interface DumpText {
+  extra?: DumpText[];
+  keybind?: string;
+  text?: string;
+  translate?: string;
+  with?: DumpText[];
+}
+export interface TaggedReference {
+  id: ResourceId;
+  kind: ReferenceKind;
+  tag?: JsonNode;
+}
+export interface JsonNode {
+  [k: string]: unknown | undefined;
+}
+export interface RecipeCategoryLayout {
+  h: number;
+  image?: string;
+  margin?: number;
+  scale?: number;
+  slots: {
+    [k: string]: RecipeLayoutSlot | undefined;
+  };
+  w: number;
+}
+export interface RecipeLayoutSlot {
+  h: number;
+  id: string;
+  role: string;
+  w: number;
+  x: number;
+  y: number;
+}

package/src/lib/dump/gen/registry/recipes.ts

@@ -0,0 +1,3 @@
+export interface RegistryRecipes {
+  [k: string]: string[] | undefined;
+}

package/src/lib/dump/gen/registry/tabs.ts

@@ -0,0 +1,46 @@
+export type ResourceId = string;
+export type ReferenceKind =
+  | "item"
+  | "block"
+  | "fluid"
+  | "entity"
+  | "itemTag"
+  | "blockTag"
+  | "fluidTag"
+  | "entityTag"
+  | "texture"
+  | "model"
+  | "recipe";
+
+export interface RegistryTabs {
+  [k: string]: TabEntry | undefined;
+}
+export interface TabEntry {
+  display: Display;
+  icon?: null | TaggedReference;
+  id: string;
+  items: TaggedReference[];
+  order: number;
+}
+export interface Display {
+  name: string;
+  tooltip: DumpText[];
+  tooltipMods: {
+    [k: string]: DumpText[] | undefined;
+  };
+}
+export interface DumpText {
+  extra?: DumpText[];
+  keybind?: string;
+  text?: string;
+  translate?: string;
+  with?: DumpText[];
+}
+export interface TaggedReference {
+  id: ResourceId;
+  kind: ReferenceKind;
+  tag?: JsonNode;
+}
+export interface JsonNode {
+  [k: string]: unknown | undefined;
+}

package/src/lib/dump/gen/registry/tags.ts

@@ -0,0 +1,11 @@
+export interface RegistryTags {
+  [k: string]: TagEntry | undefined;
+}
+export interface TagEntry {
+  id: string;
+  members?: string[];
+  producedBy?: string[];
+  registry: string;
+  replace: boolean;
+  usedBy?: string[];
+}

package/src/lib/dump/json-reader.ts

@@ -0,0 +1,231 @@
+import { parseDumpManifest } from '@terrafirmagreg-team/game/lib/dump/manifest/parse';
+import {
+  dumpStorageUrl,
+  registerDumpLocation,
+  type DumpLocation,
+} from '@terrafirmagreg-team/game/lib/dump/paths';
+import { parseDatasetRef } from '@terrafirmagreg-team/kit/lib/location';
+import type { DumpReader } from '@terrafirmagreg-team/game/lib/dump/reader';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+const SAFE_LANG_CODE = /^[a-z0-9]+(_[a-z0-9]+)*$/i;
+
+function cleanLangCode(code: string): string | undefined {
+  return SAFE_LANG_CODE.test(code) ? code : undefined;
+}
+
+const MAX_INFLIGHT = 12;
+const lanes = {
+  high: [] as Array<() => void>,
+  normal: [] as Array<() => void>,
+};
+let inflight = 0;
+
+function pump() {
+  while (inflight < MAX_INFLIGHT) {
+    const run = lanes.high.shift() ?? lanes.normal.shift();
+    if (!run) return;
+    inflight++;
+    run();
+  }
+}
+
+function fetchLane<T>(task: () => Promise<T>, high: boolean): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const run = () =>
+      task()
+        .then(resolve, reject)
+        .finally(() => {
+          inflight--;
+          pump();
+        });
+    (high ? lanes.high : lanes.normal).push(run);
+    pump();
+  });
+}
+
+const FETCH_TIMEOUT = 20_000;
+
+async function request(url: string): Promise<Response | undefined> {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      return await fetch(url, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+      });
+    } catch {
+
+    }
+  }
+  return undefined;
+}
+
+const fetchJson = createAsyncCache(
+  async (url: string, high: boolean) =>
+    fetchLane(async () => {
+      try {
+        const res = await request(url);
+        if (!res?.ok) return undefined;
+        return (await res.json()) as unknown;
+      } catch {
+        return undefined;
+      }
+    }, high),
+  (url) => url,
+);
+
+const fetchJsonGz = createAsyncCache(
+  async (url: string, high: boolean) =>
+    fetchLane(async () => {
+      try {
+        const res = await request(url);
+        if (!res?.ok || !res.body) return undefined;
+        const text = await new Response(
+          res.body.pipeThrough(new DecompressionStream('gzip')),
+        ).text();
+        return JSON.parse(text) as unknown;
+      } catch {
+        return undefined;
+      }
+    }, high),
+  (url) => url,
+);
+
+export const COMPRESSED_TREE = /^(?:data|meta)\//;
+
+function toLangMap(raw: unknown): Record<string, string> {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const map: Record<string, string> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    map[key] = typeof value === 'string' ? value : JSON.stringify(value);
+  }
+  return map;
+}
+
+export class JsonDumpReader implements DumpReader {
+  private manifestCache: Promise<ReturnType<typeof parseDumpManifest>> | undefined;
+  private locationCache: Promise<DumpLocation> | undefined;
+  private langCache = createAsyncCache((code: string) => this.loadLang(code));
+  private langRawCache = createAsyncCache((code: string) =>
+    this.loadLangRaw(code),
+  );
+  private readonly packId: string;
+  private readonly version?: string;
+
+  constructor(private dataset: string) {
+    const ref = parseDatasetRef(dataset);
+    this.packId = ref.id;
+    this.version = ref.version;
+  }
+
+  getJson(path: string, priority?: 'high'): Promise<unknown | undefined> {
+    const high = priority === 'high';
+    if (path === 'versions.json') {
+      return fetchJson(
+        dumpStorageUrl(`${this.packId}/versions.json`),
+        high,
+      );
+    }
+    return this.location().then((loc) => {
+      const key = loc.files?.[path];
+      if (key) {
+        return key.endsWith('.gz')
+          ? fetchJsonGz(dumpStorageUrl(`${key}`), high)
+          : fetchJson(dumpStorageUrl(`${key}`), high);
+      }
+
+      if (loc.files) return undefined;
+      const rel = `${loc.root}/${path}`;
+      return COMPRESSED_TREE.test(path)
+        ? fetchJsonGz(dumpStorageUrl(`${rel}.gz`), high)
+        : fetchJson(dumpStorageUrl(`${rel}`), high);
+    });
+  }
+
+  getLang(lang: string): Promise<Record<string, string>> {
+    const code = cleanLangCode(lang);
+    return code ? this.langCache(code) : Promise.resolve({});
+  }
+
+  getLangRaw(lang: string): Promise<Record<string, string>> {
+    const code = cleanLangCode(lang);
+    return code ? this.langRawCache(code) : Promise.resolve({});
+  }
+
+  private location(): Promise<DumpLocation> {
+    this.locationCache ??= this.resolveLocation();
+    return this.locationCache;
+  }
+
+  private async resolveLocation(): Promise<DumpLocation> {
+    if (this.version) {
+      const root = `${this.packId}/${this.version}`;
+      const loc: DumpLocation = { root, files: await this.objectsIndex(root) };
+      registerDumpLocation(this.dataset, loc);
+      return loc;
+    }
+    const versions = (await fetchJson(
+      dumpStorageUrl(`${this.packId}/versions.json`),
+      true,
+    )) as { latest?: string } | undefined;
+    if (versions?.latest) {
+      const root = `${this.packId}/${versions.latest}`;
+
+      const exists = await fetchJson(
+        dumpStorageUrl(`${root}/manifest.json`),
+        false,
+      );
+      if (exists) {
+        const loc: DumpLocation = { root, files: await this.objectsIndex(root) };
+        registerDumpLocation(this.dataset, loc);
+        registerDumpLocation(`${this.packId}@${versions.latest}`, loc);
+        return loc;
+      }
+    }
+    const loc: DumpLocation = { root: this.packId };
+    registerDumpLocation(this.dataset, loc);
+    return loc;
+  }
+
+  private async objectsIndex(
+    root: string,
+  ): Promise<Record<string, string> | undefined> {
+    const raw = await fetchJson(dumpStorageUrl(`${root}/objects.json`), false);
+    const files =
+      raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? (raw as Record<string, unknown>).files
+        : undefined;
+    if (!files || typeof files !== 'object' || Array.isArray(files)) {
+      return undefined;
+    }
+    const out: Record<string, string> = {};
+    for (const [rel, key] of Object.entries(files)) {
+      if (typeof key === 'string') out[rel] = key;
+    }
+    return out;
+  }
+
+  private manifest() {
+    this.manifestCache ??= this.getJson('manifest.json').then((raw) =>
+      parseDumpManifest(raw),
+    );
+    return this.manifestCache;
+  }
+
+  private async loadLang(lang: string): Promise<Record<string, string>> {
+    const codes = lang === 'en_us' ? ['en_us'] : ['en_us', lang];
+    const loc = await this.location();
+    const base = loc.files ? 'lang' : 'meta/lang';
+    const metaMaps = await Promise.all(
+      codes.map((code) =>
+        this.getJson(`${base}/${code}.json`).then(toLangMap),
+      ),
+    );
+    return Object.assign({}, ...metaMaps);
+  }
+
+  private async loadLangRaw(code: string): Promise<Record<string, string>> {
+    const loc = await this.location();
+    const base = loc.files ? 'lang' : 'meta/lang';
+    return this.getJson(`${base}/${code}.json`).then(toLangMap);
+  }
+}

package/src/lib/dump/manifest/dto.ts

@@ -0,0 +1,11 @@
+export type {
+  Display as NamespaceDisplayText,
+  DumpIndexes,
+  DumpProducer,
+  DumpText,
+  Manifest as DumpManifest,
+  NamespaceDisplay,
+  PackInfo,
+  RecipeTypeRow,
+  RecipeTypesIndex,
+} from '@terrafirmagreg-team/game/lib/dump/gen';

package/src/lib/dump/manifest/parse.ts

@@ -0,0 +1,167 @@
+import {
+  asNumber,
+  asRecord,
+  asString,
+  asStringList,
+} from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import type {
+  DumpIndexes,
+  DumpManifest,
+  DumpProducer,
+  DumpText,
+  NamespaceDisplay,
+  PackInfo,
+  RecipeTypeRow,
+} from '@terrafirmagreg-team/game/lib/dump/manifest/dto';
+
+function asProducer(value: unknown): DumpProducer | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const name = asString(row.name);
+  const platform = asString(row.platform);
+  const minecraft = asString(row.minecraft);
+  if (!name || !platform || !minecraft) return undefined;
+  return { name, platform, minecraft };
+}
+
+function asPackInfo(value: unknown): PackInfo | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const id = asString(row.id);
+  if (!id) return undefined;
+  return { id, version: typeof row.version === 'string' ? row.version : null };
+}
+
+function asDumpText(value: unknown): DumpText | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const out: DumpText = {};
+  const text = asString(row.text);
+  const translate = asString(row.translate);
+  const keybind = asString(row.keybind);
+  if (text !== undefined) out.text = text;
+  if (translate !== undefined) out.translate = translate;
+  if (keybind !== undefined) out.keybind = keybind;
+  if (Array.isArray(row.with)) {
+    out.with = row.with.flatMap((entry) => {
+      const part = asDumpText(entry);
+      return part ? [part] : [];
+    });
+  }
+  if (Array.isArray(row.extra)) {
+    out.extra = row.extra.flatMap((entry) => {
+      const part = asDumpText(entry);
+      return part ? [part] : [];
+    });
+  }
+  return out;
+}
+
+function asDisplay(value: unknown): NamespaceDisplay['display'] | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const name = asString(row.name);
+  if (!name) return undefined;
+  const tooltipMods: Record<string, DumpText[]> = {};
+  const modsRow = asRecord(row.tooltipMods);
+  if (modsRow) {
+    for (const [mod, entries] of Object.entries(modsRow)) {
+      if (!Array.isArray(entries)) continue;
+      tooltipMods[mod] = entries.flatMap((entry) => {
+        const text = asDumpText(entry);
+        return text ? [text] : [];
+      });
+    }
+  }
+  return {
+    name,
+    tooltip: Array.isArray(row.tooltip)
+      ? row.tooltip.flatMap((entry) => {
+          const text = asDumpText(entry);
+          return text ? [text] : [];
+        })
+      : [],
+    tooltipMods,
+  };
+}
+
+function asNamespaces(
+  value: unknown,
+): Record<string, NamespaceDisplay> | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const out: Record<string, NamespaceDisplay> = {};
+  for (const [ns, entry] of Object.entries(row)) {
+    if (!ns || ns.includes('/') || ns.includes('\\') || ns.includes('..')) {
+      continue;
+    }
+    const nsRow = asRecord(entry);
+    const display = asDisplay(nsRow?.display);
+    if (!display) continue;
+    out[ns] = {
+      display,
+      registry: asStringList(nsRow?.registry) ?? [],
+      guides: asStringList(nsRow?.guides) ?? [],
+      languages: asStringList(nsRow?.languages) ?? [],
+      quests: nsRow?.quests === true,
+      keybinds: nsRow?.keybinds === true,
+    };
+  }
+  return out;
+}
+
+function asRecipeTypeRow(value: unknown): RecipeTypeRow | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const id = asString(row.id);
+  const count = asNumber(row.count);
+  const filesRow = asRecord(row.files);
+  if (!id || count === undefined || !filesRow) return undefined;
+  const files: Record<string, string> = {};
+  for (const [ns, path] of Object.entries(filesRow)) {
+    if (typeof path === 'string' && path) files[ns] = path;
+  }
+  return { id, count, files };
+}
+
+function asIndexes(value: unknown): DumpIndexes | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const recipesRow = asRecord(row.recipes);
+  if (!recipesRow || !Array.isArray(recipesRow.types)) return undefined;
+  const types = recipesRow.types.flatMap((entry) => {
+    const typeRow = asRecipeTypeRow(entry);
+    return typeRow ? [typeRow] : [];
+  });
+  const quests: Record<string, string> = {};
+  const questsRow = asRecord(row.quests);
+  if (questsRow) {
+    for (const [ns, path] of Object.entries(questsRow)) {
+      if (typeof path === 'string' && path) quests[ns] = path;
+    }
+  }
+  return {
+    recipes: { types },
+    quests,
+    used: asStringList(row.used) ?? [],
+  };
+}
+
+export function parseDumpManifest(value: unknown): DumpManifest | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  if (asString(row.schema) !== 'manifest') return undefined;
+  const producer = asProducer(row.producer);
+  const indexes = asIndexes(row.indexes);
+  const namespaces = asNamespaces(row.namespaces);
+  if (!producer || !indexes || !namespaces) return undefined;
+  return {
+    schema: 'manifest',
+    producer,
+    pack: asPackInfo(row.pack) ?? null,
+    languages: asStringList(row.languages),
+    layout: asString(row.layout) ?? 'v1',
+    namespaces,
+    indexes,
+  };
+}

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

@@ -0,0 +1,40 @@
+import type { DumpManifest } from '@terrafirmagreg-team/game/lib/dump/manifest/dto';
+
+export type GuideBookRef = {
+  namespace: string;
+  modId: string;
+  bookPath: string;
+  bookId: string;
+  dir: string;
+  locales: string[];
+};
+
+export type ClientDumpMod = {
+  namespace: string;
+  books: GuideBookRef[];
+};
+
+export type DumpMod = {
+  namespace: string;
+  languages: Record<string, string>;
+  keybindsFile: string | null;
+  items: string | null;
+  blocks: string | null;
+  fluids: string | null;
+  entities: string | null;
+  tabs: string | null;
+  groups: string | null;
+  recipeCategories: string | null;
+  tags: string | null;
+  recipeIndex: string | null;
+  modelIndex: string | null;
+  questData: string | null;
+  guides: Record<string, string>;
+  books: GuideBookRef[];
+};
+
+export type DumpIndex = {
+  root: string;
+  manifest: DumpManifest;
+  mods: DumpMod[];
+};