@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/calc/storage/index.ts

@@ -0,0 +1,20 @@
+export {
+  migrateCalcState,
+  newCalcEntry,
+  type CalcTreeEntry,
+} from './entry';
+export { calcStorageKey } from './keys';
+export {
+  readCalcActive,
+  readCalcHistory,
+  resolveCalcActive,
+  readCalcStorage,
+  readCalcTabs,
+  removeCalcHistory,
+  subscribeCalcStorage,
+  updateCalcTab,
+  writeCalcActive,
+  writeCalcStorage,
+  writeCalcTabs,
+} from './store';
+

package/src/lib/calc/storage/keys.ts

@@ -0,0 +1,38 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+export const CALC_STATE_EVENT = 'tfg:calc-state';
+const TAB_KEY = 'tfg:calc-tab';
+const ACTIVE_PREFIX = 'calc:active:';
+const HIST_PREFIX = 'calc:hist:';
+
+let tabId: string | null = null;
+
+function calcTabId(): string {
+  if (tabId) return tabId;
+  try {
+    tabId = window.sessionStorage.getItem(TAB_KEY);
+    if (!tabId) {
+      tabId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+      window.sessionStorage.setItem(TAB_KEY, tabId);
+    }
+  } catch {
+    tabId ??= `tab-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  return tabId;
+}
+
+export function calcStorageKey(section: string, dataset: DatasetRef): string {
+  void calcTabId();
+  return `calc:tabs:${section}:${dataset.id}/${dataset.version ?? ''}`;
+}
+
+export function activeKey(key: string): string {
+  return `${ACTIVE_PREFIX}${key}@${calcTabId()}`;
+}
+
+export function historyKey(key: string): string {
+  return `${HIST_PREFIX}${key}`;
+}
+
+export const emitCalcStorage = () =>
+  window.dispatchEvent(new Event(CALC_STATE_EVENT));
+

package/src/lib/calc/storage/store.ts

@@ -0,0 +1,198 @@
+import type { CalculatorState } from '@terrafirmagreg-team/recipe/types/calc';
+import {
+  capHistory,
+  EMPTY_ENTRIES,
+  isCalcHistory,
+  isCalcTabs,
+  migrateCalcState,
+  newCalcEntry,
+  type CalcTreeEntry,
+} from './entry';
+import {
+  activeKey,
+  CALC_STATE_EVENT,
+  emitCalcStorage,
+  historyKey,
+} from './keys';
+
+function readJSON<T>(raw: string | null, guard: (v: unknown) => v is T): T | null {
+  if (raw === null) return null;
+  try {
+    const value = JSON.parse(raw) as unknown;
+    return guard(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+const snapshots = new Map<string, { raw: string | null; value: unknown }>();
+
+function snap<T>(
+  storeKey: string,
+  raw: string | null,
+  guard: (v: unknown) => v is T,
+  normalize?: (value: T) => void,
+): T | null {
+  const hit = snapshots.get(storeKey);
+  if (hit && hit.raw === raw) return hit.value as T | null;
+  const value = readJSON(raw, guard);
+  if (value) normalize?.(value);
+  snapshots.set(storeKey, { raw, value });
+  return value;
+}
+
+const migrateEntries = (entries: CalcTreeEntry[]): void => {
+  for (const entry of entries) {
+    entry.state = migrateCalcState(entry.state);
+  }
+};
+
+export function readCalcTabs(key: string): CalcTreeEntry[] {
+  if (typeof window === 'undefined') return [];
+  return (
+    snap(key, window.localStorage.getItem(key), isCalcTabs, migrateEntries) ??
+    EMPTY_ENTRIES
+  );
+}
+
+export function readCalcActive(key: string): string | null {
+  if (typeof window === 'undefined') return null;
+  try {
+    return window.sessionStorage.getItem(activeKey(key)) || null;
+  } catch {
+    return null;
+  }
+}
+
+export function readCalcHistory(key: string): CalcTreeEntry[] {
+  if (typeof window === 'undefined') return [];
+  const hKey = historyKey(key);
+  return (
+    snap(hKey, window.localStorage.getItem(hKey), isCalcHistory, migrateEntries) ??
+    EMPTY_ENTRIES
+  );
+}
+
+function writeTabsRaw(key: string, tabs: CalcTreeEntry[]): void {
+  window.localStorage.setItem(key, JSON.stringify(tabs));
+}
+
+function writeHistoryRaw(key: string, entries: CalcTreeEntry[]): void {
+  window.localStorage.setItem(
+    historyKey(key),
+    JSON.stringify(capHistory(entries)),
+  );
+}
+
+function syncHistory(key: string, tabs: CalcTreeEntry[]): void {
+  const live = tabs.filter((tab) => tab.state.cards.length);
+  if (!live.length) return;
+  const prev = readCalcHistory(key);
+  const ids = new Set(live.map((tab) => tab.id));
+  writeHistoryRaw(key, [...live, ...prev.filter((e) => !ids.has(e.id))]);
+}
+
+export function writeCalcTabs(
+  key: string,
+  tabs: CalcTreeEntry[],
+  active: string | null,
+): void {
+  if (typeof window === 'undefined') return;
+  try {
+    writeTabsRaw(key, tabs);
+    syncHistory(key, tabs);
+    window.sessionStorage.setItem(activeKey(key), active ?? '');
+  } catch {
+    return;
+  }
+  emitCalcStorage();
+}
+
+export function writeCalcActive(key: string, id: string | null): void {
+  if (typeof window === 'undefined') return;
+  try {
+    window.sessionStorage.setItem(activeKey(key), id ?? '');
+  } catch {
+    return;
+  }
+  emitCalcStorage();
+}
+
+export function updateCalcTab(
+  key: string,
+  id: string,
+  update: (entry: CalcTreeEntry) => CalcTreeEntry,
+): void {
+  if (typeof window === 'undefined') return;
+  const tabs = readCalcTabs(key);
+  const index = tabs.findIndex((tab) => tab.id === id);
+  if (index < 0) return;
+  const next = tabs.slice();
+  next[index] = update(next[index]!);
+  try {
+    writeTabsRaw(key, next);
+    syncHistory(key, next);
+  } catch {
+    return;
+  }
+  emitCalcStorage();
+}
+
+export function removeCalcHistory(key: string, id: string): void {
+  if (typeof window === 'undefined') return;
+  try {
+    writeHistoryRaw(
+      key,
+      readCalcHistory(key).filter((entry) => entry.id !== id),
+    );
+    const tabs = readCalcTabs(key).filter((tab) => tab.id !== id);
+    writeTabsRaw(key, tabs);
+    if (readCalcActive(key) === id) {
+      window.sessionStorage.setItem(activeKey(key), '');
+    }
+  } catch {
+    return;
+  }
+  emitCalcStorage();
+}
+
+export function resolveCalcActive(
+  tabs: readonly CalcTreeEntry[],
+  raw: string | null,
+): string | null {
+  return (tabs.find((tab) => tab.id === raw) ?? tabs[0])?.id ?? null;
+}
+
+export function readCalcStorage(key: string): CalculatorState | null {
+  const tabs = readCalcTabs(key);
+  const active = resolveCalcActive(tabs, readCalcActive(key));
+  return tabs.find((tab) => tab.id === active)?.state ?? null;
+}
+
+export function writeCalcStorage(
+  key: string,
+  state: CalculatorState,
+): void {
+  const tabs = readCalcTabs(key);
+  const active = resolveCalcActive(tabs, readCalcActive(key));
+  const index = tabs.findIndex((tab) => tab.id === active);
+  if (index >= 0) {
+    const next = tabs.slice();
+    next[index] = { ...next[index]!, savedAt: Date.now(), state };
+    writeCalcTabs(key, next, active);
+    return;
+  }
+  const entry = newCalcEntry(state);
+  writeCalcTabs(key, [...tabs, entry], entry.id);
+}
+
+export function subscribeCalcStorage(listener: () => void): () => void {
+  if (typeof window === 'undefined') return () => {};
+  window.addEventListener(CALC_STATE_EVENT, listener);
+  window.addEventListener('storage', listener);
+  return () => {
+    window.removeEventListener(CALC_STATE_EVENT, listener);
+    window.removeEventListener('storage', listener);
+  };
+}
+

package/src/lib/calc/tree/index.ts

@@ -0,0 +1,4 @@
+export { mergeAmounts } from './materials';
+export { recipeDivisor, toCalcRecipe } from './recipe';
+export { decodeCalcState, encodeCalcState } from './share';
+

package/src/lib/calc/tree/materials.ts

@@ -0,0 +1,29 @@
+import type { CalcKind, CalcMaterial } from '@terrafirmagreg-team/recipe/types/calc';
+
+export function materialKey(kind: CalcKind, id: string): string {
+  return `${kind}:${id}`;
+}
+
+export function mergeAmounts(list: CalcMaterial[]): CalcMaterial[] {
+  const map = new Map<string, CalcMaterial>();
+  for (const row of list) {
+    const key = materialKey(row.kind, row.id);
+    const existing = map.get(key);
+    if (existing) existing.amount += row.amount;
+    else map.set(key, { ...row });
+  }
+  return [...map.values()];
+}
+
+export function deduplicateMaterials(list: CalcMaterial[]): CalcMaterial[] {
+  const seen = new Set<string>();
+  const result: CalcMaterial[] = [];
+  for (const row of list) {
+    const key = materialKey(row.kind, row.id);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push({ ...row });
+  }
+  return result;
+}
+

package/src/lib/calc/tree/recipe.ts

@@ -0,0 +1,104 @@
+import type { Recipe, RecipeIngredient } from '@terrafirmagreg-team/recipe/lib/data/dto';
+import type {
+  CalcKind,
+  CalcMaterial,
+  CalcRecipe,
+  CalcRecipeInput,
+} from '@terrafirmagreg-team/recipe/types/calc';
+
+function slotKind(slot: { kind: RecipeIngredient['kind'] }): CalcKind {
+  return slot.kind === 'fluid' ? 'fluid' : 'item';
+}
+
+const GT_TIERS: Record<string, number> = {
+  ULV: 0,
+  LV: 1,
+  MV: 2,
+  HV: 3,
+  EV: 4,
+  IV: 5,
+  LuV: 6,
+  ZPM: 7,
+  UV: 8,
+  UHV: 9,
+  UEV: 10,
+  UIV: 11,
+  UXV: 12,
+  OpV: 13,
+  MAX: 14,
+};
+
+function recipeTier(recipe: Recipe): number | undefined {
+  for (const widget of recipe.widgets) {
+    if (widget.type !== 'text' || !widget.component) continue;
+    for (const part of [
+      widget.component,
+      ...(widget.component.extra ?? []),
+    ]) {
+      if (part.translate !== 'gtceu.recipe.eu') continue;
+      for (const arg of part.with ?? []) {
+        if (arg.text && arg.text in GT_TIERS) return GT_TIERS[arg.text];
+      }
+    }
+  }
+  return undefined;
+}
+
+export function toCalcRecipe(recipe: Recipe): CalcRecipe {
+  const inputs: CalcRecipeInput[] = recipe.inputs.map((slot) => ({
+    id: slot.id,
+    kind: slotKind(slot),
+    amount: slot.count && slot.count > 0 ? slot.count : 1,
+    catalyst: false,
+    ...(slot.chance !== undefined ? { chance: slot.chance } : {}),
+    ...(slot.kind === 'tag' ? { tagId: slot.id } : {}),
+  }));
+  for (const widget of recipe.widgets) {
+    if (widget.type !== 'slot' || widget.role !== 'catalyst') continue;
+    inputs.push({
+      id: widget.id,
+      kind: widget.kind === 'fluid' ? 'fluid' : 'item',
+      amount: 1,
+      catalyst: true,
+      ...(widget.chance !== undefined ? { chance: widget.chance } : {}),
+      ...(widget.kind === 'tag' ? { tagId: widget.id } : {}),
+    });
+  }
+  const merged: CalcRecipeInput[] = [];
+  for (const input of inputs) {
+    const key = `${input.kind}:${input.id}:${input.catalyst}:${input.tagId ?? ''}:${input.chance ?? ''}`;
+    const existing = merged.find(
+      (row) =>
+        `${row.kind}:${row.id}:${row.catalyst}:${row.tagId ?? ''}:${row.chance ?? ''}` ===
+        key,
+    );
+    if (existing) existing.amount += input.amount;
+    else merged.push({ ...input });
+  }
+  const outputs: CalcMaterial[] = recipe.outputs.map((slot) => ({
+    id: slot.id,
+    kind: slotKind(slot),
+    amount: slot.count && slot.count > 0 ? slot.count : 1,
+    ...(slot.chance !== undefined ? { chance: slot.chance } : {}),
+  }));
+  const tier = recipeTier(recipe);
+  return {
+    recipeId: recipe.id,
+    category: recipe.category ?? recipe.type,
+    inputs: merged,
+    outputs,
+    ...(tier !== undefined ? { tier } : {}),
+  };
+}
+
+export function recipeDivisor(
+  recipe: CalcRecipe,
+  materialId: string,
+  kind: CalcKind,
+): number {
+  const amount = recipe.outputs
+    .filter((out) => out.id === materialId && out.kind === kind)
+    .reduce((sum, out) => sum + out.amount * (out.chance ?? 1), 0);
+  return amount > 0 ? amount : 1;
+}
+

package/src/lib/calc/tree/share.ts

@@ -0,0 +1,135 @@
+import { deflateSync, inflateSync, strFromU8, strToU8 } from 'fflate';
+import type {
+  CalcCard,
+  CalculatorState,
+  CalcWire,
+} from '@terrafirmagreg-team/recipe/types/calc';
+
+function encodeUrlSafe(base64: string): string {
+  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+function decodeUrlSafe(encoded: string): string {
+  let result = encoded;
+  const pad = result.length % 4;
+  if (pad) result += '='.repeat(4 - pad);
+  return result.replace(/-/g, '+').replace(/_/g, '/');
+}
+
+function u8ToBinary(u8: Uint8Array): string {
+  let bin = '';
+  for (let i = 0; i < u8.length; i += 8192) {
+    bin += String.fromCharCode(...u8.subarray(i, i + 8192));
+  }
+  return bin;
+}
+
+export function encodeCalcState(state: CalculatorState): string {
+  const dict = new Map<string, number>();
+  const ref = (id: string): number => {
+    const hit = dict.get(id);
+    if (hit !== undefined) return hit;
+    const idx = dict.size;
+    dict.set(id, idx);
+    return idx;
+  };
+  const indexOf = new Map<string, number>();
+  const cards = state.cards.map((card, index) => {
+    indexOf.set(card.id, index);
+    const row = [
+      ref(card.materialId),
+      card.kind === 'fluid' ? 1 : 0,
+      card.recipeId ? ref(card.recipeId) : -1,
+      card.crafts,
+      Math.round(card.pos?.x ?? 0),
+      Math.round(card.pos?.y ?? 0),
+      card.pos ? 1 : 0,
+    ];
+    return row;
+  });
+  const wires = state.wires.flatMap((wire) => {
+    const from = indexOf.get(wire.from);
+    const to = indexOf.get(wire.to);
+    return from === undefined || to === undefined
+      ? []
+      : [[from, to, wire.input, wire.out ?? 0, wire.amount ?? 0]];
+  });
+  const tagSelections: Record<string, number> = {};
+  for (const [tagId, memberId] of Object.entries(state.tagSelections)) {
+    if (memberId) tagSelections[String(ref(tagId))] = ref(memberId);
+  }
+  const payload = {
+    v: 2,
+    d: [...dict.keys()],
+    c: cards,
+    w: wires,
+    g: tagSelections,
+  };
+  const packed = deflateSync(strToU8(JSON.stringify(payload)));
+  return `x${encodeUrlSafe(btoa(u8ToBinary(packed)))}`;
+}
+
+export function decodeCalcState(encoded: string): CalculatorState | null {
+  const text = encoded.trim();
+  if (!text.startsWith('x')) return null;
+  try {
+    const bin = atob(decodeUrlSafe(text.slice(1)));
+    const packed = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+    const payload = JSON.parse(strFromU8(inflateSync(packed))) as {
+      v?: number;
+      d?: string[];
+      c?: number[][];
+      w?: number[][];
+      g?: Record<string, number>;
+    };
+    if (payload.v !== 2 || !Array.isArray(payload.d)) return null;
+    const dict = payload.d;
+    const id = (idx: unknown): string | null =>
+      typeof idx === 'number' && idx >= 0 && idx < dict.length
+        ? dict[idx]!
+        : null;
+    const cards: CalcCard[] = [];
+    for (const [index, row] of (payload.c ?? []).entries()) {
+      if (!Array.isArray(row)) continue;
+      const materialId = id(row[0]);
+      if (!materialId) continue;
+      const kind = row[1] === 1 ? 'fluid' : 'item';
+      const recipeId = row[2] === -1 ? null : id(row[2]);
+      cards.push({
+        id: `c${index}`,
+        materialId,
+        kind,
+        recipeId: recipeId ?? null,
+        crafts: Number(row[3]) || 1,
+        pos:
+          row[6] === 1
+            ? { x: Number(row[4]) || 0, y: Number(row[5]) || 0 }
+            : undefined,
+      });
+    }
+    const wires: CalcWire[] = [];
+    for (const row of payload.w ?? []) {
+      if (!Array.isArray(row)) continue;
+      const from = cards[row[0]!];
+      const to = cards[row[1]!];
+      if (!from || !to) continue;
+      wires.push({
+        from: from.id,
+        to: to.id,
+        input: Number(row[2]) || 0,
+        out: Number(row[3]) || undefined,
+        amount: Number(row[4]) || undefined,
+      });
+    }
+    const tagSelections: Record<string, string> = {};
+    for (const [tagIdx, memberIdx] of Object.entries(payload.g ?? {})) {
+      const tagId = id(Number(tagIdx));
+      const memberId = id(memberIdx);
+      if (tagId && memberId) tagSelections[tagId] = memberId;
+    }
+    return { cards, wires, tagSelections };
+  } catch {
+    return null;
+  }
+}
+

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

@@ -0,0 +1,25 @@
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
+import type { RecipeCompactIndex } from '@terrafirmagreg-team/recipe/types';
+import type { FlushHandler, ResolveInput } from './protocol';
+import { runResolve } from './resolve';
+import { resetWorkerState, state } from './state';
+
+export const api = {
+  async init(
+    nextDataset: DatasetRef,
+    nextCatalog: RecipeCompactIndex,
+    flushHandler: FlushHandler,
+  ) {
+    resetWorkerState(nextDataset, nextCatalog);
+    state.onFlush = flushHandler;
+  },
+  async resolve(input: ResolveInput) {
+    state.resolveGen += 1;
+    await runResolve(input);
+  },
+  async invalidate() {
+    state.resolveGen += 1;
+    state.epoch += 1;
+  },
+};
+

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

@@ -0,0 +1,66 @@
+import type { CalcKind, CalcRecipe, CalcRecipeSummary } from '@terrafirmagreg-team/recipe/types/calc';
+import { fetchSlices, summarizeRecipes } from '@terrafirmagreg-team/recipe/lib/calc/resolve';
+import type { Pending } from './flush';
+import { state } from './state';
+
+export function createWorkerSummaries(
+  localRecipes: ReadonlyMap<string, CalcRecipe>,
+) {
+  const cache = new Map<string, CalcRecipeSummary[]>();
+  return {
+    get: (materialId: string, kind: CalcKind): CalcRecipeSummary[] =>
+      summarizeRecipes(
+        state.outMap,
+        localRecipes,
+        state.catalog?.types ?? [],
+        cache,
+        materialId,
+        kind,
+      ),
+    clear: () => cache.clear(),
+  };
+}
+
+export async function fetchWanted(
+  pending: Pending,
+  wanted: Set<string>,
+  wantedOut: Set<string>,
+  wantedTag: Set<string>,
+  localRecipes: Map<string, CalcRecipe>,
+): Promise<boolean> {
+  if (!state.catalog) return false;
+  const slices = await fetchSlices(state.dataset, state.catalog, {
+    recipes: wanted,
+    outs: wantedOut,
+    tags: wantedTag,
+  });
+  let progressed = false;
+  for (const id of slices.dead) {
+    if (state.deadIds.has(id)) continue;
+    state.deadIds.add(id);
+    pending.dead.add(id);
+    pending.dirty = true;
+  }
+  for (const [id, entry] of slices.recipes) {
+    localRecipes.set(id, entry.calc);
+    state.bodyMap.set(id, entry.body);
+    pending.recipes.set(id, entry.calc);
+    pending.bodies.set(id, entry.body);
+    pending.dirty = true;
+    progressed = true;
+  }
+  for (const [id, list] of slices.outs) {
+    state.outMap.set(id, list);
+    pending.out.set(id, list);
+    pending.dirty = true;
+    progressed = true;
+  }
+  for (const [id, resolution] of slices.tags) {
+    state.tagMap.set(id, resolution);
+    pending.tag.set(id, resolution);
+    pending.dirty = true;
+    progressed = true;
+  }
+  return progressed;
+}
+

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

@@ -0,0 +1,39 @@
+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';
+import { state } from './state';
+
+export function createFlush() {
+  return {
+    out: new Map<string, RecipeCompactRow[]>(),
+    tag: new Map<string, TagResolution>(),
+    recipes: new Map<string, CalcRecipe>(),
+    bodies: new Map<string, Recipe>(),
+    dead: new Set<string>(),
+    dirty: false,
+  };
+}
+
+export type Pending = ReturnType<typeof createFlush>;
+
+export function postFlush(pending: Pending) {
+  if (!pending.dirty) return;
+  pending.dirty = false;
+  state.onFlush({
+    epoch: state.epoch,
+    out: [...pending.out],
+    tag: [...pending.tag],
+    recipes: [...pending.recipes],
+    bodies: [...pending.bodies],
+    dead: [...pending.dead],
+  });
+  pending.out.clear();
+  pending.tag.clear();
+  pending.recipes.clear();
+  pending.bodies.clear();
+  pending.dead.clear();
+}
+

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

@@ -0,0 +1,8 @@
+import { expose } from 'comlink';
+import { api } from './api';
+
+export type CalcWorkerApi = typeof api;
+export type { CalcWorkerFlush } from './protocol';
+
+expose(api);
+