@unicitylabs/sphere-ui 0.1.0

package/dist/hooks/index.js

@@ -0,0 +1,813 @@
+// src/hooks/useCanvasState.ts
+import { useState, useCallback, useMemo, useEffect, useRef } from "react";
+import { arrayMove } from "@dnd-kit/sortable";
+function chainColor(group) {
+  let hash = 0;
+  for (const c of group) hash = hash * 31 + c.charCodeAt(0) & 4294967295;
+  const hue = Math.abs(hash) % 360;
+  return `hsl(${hue}, 70%, 55%)`;
+}
+function parseDndId(id) {
+  if (id === "unassigned") return { type: "unassigned", rawId: "unassigned" };
+  const [type, rawId] = id.split(":");
+  return { type, rawId };
+}
+function normalizeLaneId(id) {
+  if (id.startsWith("lane:")) return id.replace("lane:", "track:");
+  return id;
+}
+function getLaneId(quest) {
+  if (quest.trackId) return `track:${quest.trackId}`;
+  return "unassigned";
+}
+function useCanvasState(tracks, quests) {
+  const [trackOrder, setTrackOrder] = useState([]);
+  const [questOrderByLane, setQuestOrderByLane] = useState(/* @__PURE__ */ new Map());
+  const [selectedItem, setSelectedItem] = useState(null);
+  const [activePanelTab, setActivePanelTab] = useState("quests");
+  const [pendingChanges, setPendingChanges] = useState([]);
+  const [localQuestFields, setLocalQuestFields] = useState(/* @__PURE__ */ new Map());
+  const [localTrackFields, setLocalTrackFields] = useState(/* @__PURE__ */ new Map());
+  const undoStack = useRef([]);
+  const [activeDragId, setActiveDragId] = useState(null);
+  const dragSourceLane = useRef(null);
+  useEffect(() => {
+    const sortedTracks = [...tracks].sort((a, b) => a.sortOrder - b.sortOrder);
+    setTrackOrder(sortedTracks.map((t) => `track:${t._id}`));
+    const byLane = /* @__PURE__ */ new Map();
+    for (const t of sortedTracks) {
+      const laneId = `track:${t._id}`;
+      const laneQuests = quests.filter((q) => getLaneId(q) === laneId).sort((a, b) => a.sortOrder - b.sortOrder);
+      byLane.set(laneId, laneQuests.map((q) => `quest:${q._id}`));
+    }
+    const unassigned = quests.filter((q) => getLaneId(q) === "unassigned").sort((a, b) => a.sortOrder - b.sortOrder);
+    byLane.set("unassigned", unassigned.map((q) => `quest:${q._id}`));
+    setQuestOrderByLane(byLane);
+    setPendingChanges([]);
+    setLocalQuestFields(/* @__PURE__ */ new Map());
+    setLocalTrackFields(/* @__PURE__ */ new Map());
+  }, [tracks, quests]);
+  const pushUndo = useCallback(() => {
+    undoStack.current = [
+      ...undoStack.current.slice(-19),
+      {
+        trackOrder,
+        questOrderByLane: new Map(questOrderByLane),
+        localQuestFields: new Map(localQuestFields),
+        localTrackFields: new Map(localTrackFields),
+        pendingChanges: [...pendingChanges]
+      }
+    ];
+  }, [trackOrder, questOrderByLane, localQuestFields, localTrackFields, pendingChanges]);
+  const undo = useCallback(() => {
+    const entry = undoStack.current.pop();
+    if (!entry) return;
+    setTrackOrder(entry.trackOrder);
+    setQuestOrderByLane(entry.questOrderByLane);
+    setLocalQuestFields(entry.localQuestFields);
+    setLocalTrackFields(entry.localTrackFields);
+    setPendingChanges(entry.pendingChanges);
+  }, []);
+  const getQuest = useCallback((id) => {
+    const base = quests.find((q) => q._id === id);
+    if (!base) return void 0;
+    const overrides = localQuestFields.get(id);
+    return overrides ? { ...base, ...overrides } : base;
+  }, [quests, localQuestFields]);
+  const getTrack = useCallback((id) => {
+    const base = tracks.find((t) => t._id === id);
+    if (!base) return void 0;
+    const overrides = localTrackFields.get(id);
+    return overrides ? { ...base, ...overrides } : base;
+  }, [tracks, localTrackFields]);
+  const getQuestsForLane = useCallback((laneId) => {
+    const ids = questOrderByLane.get(laneId) ?? [];
+    return ids.map((dndId) => {
+      const { rawId } = parseDndId(dndId);
+      return getQuest(rawId);
+    }).filter((q) => Boolean(q));
+  }, [questOrderByLane, getQuest]);
+  const findLaneForQuest = useCallback((questDndId) => {
+    for (const [laneId, ids] of questOrderByLane) {
+      if (ids.includes(questDndId)) return laneId;
+    }
+    return void 0;
+  }, [questOrderByLane]);
+  const updateQuestField = useCallback((id, fields) => {
+    pushUndo();
+    setLocalQuestFields((m) => {
+      const next = new Map(m);
+      next.set(id, { ...next.get(id) ?? {}, ...fields });
+      return next;
+    });
+    setPendingChanges((p) => [...p, { kind: "quest-field", id, fields }]);
+    const laneChanged = "trackId" in fields;
+    if (laneChanged) {
+      const questDndId = `quest:${id}`;
+      const newLane = fields.trackId ? `track:${fields.trackId}` : "unassigned";
+      setQuestOrderByLane((prev) => {
+        const next = new Map(prev);
+        for (const [laneId, ids] of next) {
+          if (ids.includes(questDndId)) {
+            next.set(laneId, ids.filter((qid) => qid !== questDndId));
+            break;
+          }
+        }
+        const target = next.get(newLane) ?? [];
+        if (!target.includes(questDndId)) {
+          next.set(newLane, [...target, questDndId]);
+        }
+        return next;
+      });
+    }
+  }, [pushUndo]);
+  const updateTrackField = useCallback((id, fields) => {
+    pushUndo();
+    setLocalTrackFields((m) => {
+      const next = new Map(m);
+      next.set(id, { ...next.get(id) ?? {}, ...fields });
+      return next;
+    });
+    setPendingChanges((p) => [...p, { kind: "track-field", id, fields }]);
+  }, [pushUndo]);
+  const handleDragStart = useCallback((id) => {
+    setActiveDragId(id);
+    dragSourceLane.current = findLaneForQuest(id) ?? null;
+  }, [findLaneForQuest]);
+  const handleDragOver = useCallback((event) => {
+    const { active, over } = event;
+    if (!over) return;
+    const activeId = String(active.id);
+    const overId = String(over.id);
+    const { type: activeType } = parseDndId(activeId);
+    if (activeType !== "quest") return;
+    const sourceLane = findLaneForQuest(activeId);
+    if (!sourceLane) return;
+    let targetLane;
+    const normalizedOverId = normalizeLaneId(overId);
+    const { type: overType } = parseDndId(normalizedOverId);
+    if (overType === "track" || normalizedOverId === "unassigned") {
+      targetLane = normalizedOverId;
+    } else if (overType === "quest") {
+      targetLane = findLaneForQuest(normalizedOverId) ?? sourceLane;
+    } else {
+      return;
+    }
+    if (sourceLane === targetLane) return;
+    setQuestOrderByLane((prev) => {
+      const next = new Map(prev);
+      const srcList = (next.get(sourceLane) ?? []).filter((id) => id !== activeId);
+      const tgtList = (next.get(targetLane) ?? []).filter((id) => id !== activeId);
+      const overIdx = tgtList.indexOf(overId);
+      if (overIdx !== -1) {
+        tgtList.splice(overIdx, 0, activeId);
+      } else {
+        tgtList.push(activeId);
+      }
+      next.set(sourceLane, srcList);
+      next.set(targetLane, tgtList);
+      return next;
+    });
+  }, [findLaneForQuest]);
+  const handleDragEnd = useCallback((event) => {
+    const { active, over } = event;
+    setActiveDragId(null);
+    if (!over) return;
+    const activeId = String(active.id);
+    const overId = String(over.id);
+    const { type: activeType, rawId: activeRawId } = parseDndId(activeId);
+    if (activeType === "track") {
+      if (activeId === overId) return;
+      pushUndo();
+      const newOrder = arrayMove(
+        trackOrder,
+        trackOrder.indexOf(activeId),
+        trackOrder.indexOf(overId)
+      );
+      setTrackOrder(newOrder);
+      setPendingChanges((p) => [...p, { kind: "track-reorder" }]);
+      return;
+    }
+    if (activeType === "quest") {
+      const currentLane = findLaneForQuest(activeId);
+      if (!currentLane) return;
+      const sourceLane = dragSourceLane.current;
+      dragSourceLane.current = null;
+      const isCrossLane = sourceLane !== null && sourceLane !== currentLane;
+      if (isCrossLane) {
+        pushUndo();
+        setPendingChanges((p) => [
+          ...p,
+          { kind: "quest-reorder", laneId: currentLane },
+          { kind: "quest-reorder", laneId: sourceLane }
+        ]);
+        const track = currentLane === "unassigned" ? null : tracks.find((t) => `track:${t._id}` === currentLane);
+        const newTrackId = track?._id ?? null;
+        setPendingChanges((p) => [...p, { kind: "quest-field", id: activeRawId, fields: { trackId: newTrackId } }]);
+        setLocalQuestFields((m) => {
+          const next = new Map(m);
+          next.set(activeRawId, { ...next.get(activeRawId) ?? {}, trackId: newTrackId });
+          return next;
+        });
+        return;
+      }
+      const laneIds = questOrderByLane.get(currentLane) ?? [];
+      if (activeId === overId) return;
+      pushUndo();
+      const newLaneIds = arrayMove(laneIds, laneIds.indexOf(activeId), laneIds.indexOf(overId));
+      setQuestOrderByLane((prev) => {
+        const next = new Map(prev);
+        next.set(currentLane, newLaneIds);
+        return next;
+      });
+      setPendingChanges((p) => [...p, { kind: "quest-reorder", laneId: currentLane }]);
+    }
+  }, [trackOrder, questOrderByLane, tracks, findLaneForQuest, pushUndo]);
+  const reset = useCallback(() => {
+    const sortedTracks = [...tracks].sort((a, b) => a.sortOrder - b.sortOrder);
+    setTrackOrder(sortedTracks.map((t) => `track:${t._id}`));
+    const byLane = /* @__PURE__ */ new Map();
+    for (const t of sortedTracks) {
+      const laneId = `track:${t._id}`;
+      const laneQuests = quests.filter((q) => getLaneId(q) === laneId).sort((a, b) => a.sortOrder - b.sortOrder);
+      byLane.set(laneId, laneQuests.map((q) => `quest:${q._id}`));
+    }
+    const unassigned = quests.filter((q) => getLaneId(q) === "unassigned").sort((a, b) => a.sortOrder - b.sortOrder);
+    byLane.set("unassigned", unassigned.map((q) => `quest:${q._id}`));
+    setQuestOrderByLane(byLane);
+    setPendingChanges([]);
+    setLocalQuestFields(/* @__PURE__ */ new Map());
+    setLocalTrackFields(/* @__PURE__ */ new Map());
+    undoStack.current = [];
+  }, [tracks, quests]);
+  const selectItem = useCallback((item) => {
+    setSelectedItem(item);
+    if (item) setActivePanelTab("settings");
+  }, []);
+  const orderedTracks = useMemo(() => {
+    return trackOrder.map((dndId) => {
+      const { rawId } = parseDndId(dndId);
+      return getTrack(rawId);
+    }).filter((t) => Boolean(t));
+  }, [trackOrder, getTrack]);
+  return {
+    // Data
+    orderedTracks,
+    getQuestsForLane,
+    getQuest,
+    getTrack,
+    trackOrder,
+    questOrderByLane,
+    // DnD
+    activeDragId,
+    handleDragStart,
+    handleDragOver,
+    handleDragEnd,
+    // Selection
+    selectedItem,
+    selectItem,
+    // Panel
+    activePanelTab,
+    setActivePanelTab,
+    // Edits
+    updateQuestField,
+    updateTrackField,
+    // Undo
+    undo,
+    // Pending changes
+    pendingChanges,
+    hasPendingChanges: pendingChanges.length > 0,
+    clearPendingChanges: () => setPendingChanges([]),
+    reset
+  };
+}
+
+// src/hooks/useAchievementCanvasState.ts
+import { useState as useState2, useCallback as useCallback2, useMemo as useMemo2, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { arrayMove as arrayMove2 } from "@dnd-kit/sortable";
+function parseDndId2(id) {
+  if (id === "unassigned") return { type: "unassigned", rawId: "unassigned" };
+  const [type, rawId] = id.split(":");
+  return { type, rawId };
+}
+function normalizeLaneId2(id) {
+  if (id.startsWith("lane:")) return id.replace("lane:", "track:");
+  return id;
+}
+function getAchLaneId(ach) {
+  if (ach.trackId) return `track:${ach.trackId}`;
+  return "unassigned";
+}
+function useAchievementCanvasState(tracks, achievements) {
+  const [trackOrder, setTrackOrder] = useState2([]);
+  const [achOrderByLane, setAchOrderByLane] = useState2(/* @__PURE__ */ new Map());
+  const [selectedItem, setSelectedItem] = useState2(null);
+  const [activePanelTab, setActivePanelTab] = useState2("achievements");
+  const [groupMode, setGroupMode] = useState2("track");
+  const [pendingChanges, setPendingChanges] = useState2([]);
+  const [localAchFields, setLocalAchFields] = useState2(/* @__PURE__ */ new Map());
+  const [localTrackFields, setLocalTrackFields] = useState2(/* @__PURE__ */ new Map());
+  const undoStack = useRef2([]);
+  const [activeDragId, setActiveDragId] = useState2(null);
+  useEffect2(() => {
+    const sortedTracks = [...tracks].sort((a, b) => a.sortOrder - b.sortOrder);
+    setTrackOrder(sortedTracks.map((t) => `track:${t._id}`));
+    const byLane = /* @__PURE__ */ new Map();
+    for (const t of sortedTracks) {
+      const laneId = `track:${t._id}`;
+      const laneAchs = achievements.filter((a) => getAchLaneId(a) === laneId).sort((a, b) => a.sortOrder - b.sortOrder);
+      byLane.set(laneId, laneAchs.map((a) => `ach:${a._id}`));
+    }
+    const unassigned = achievements.filter((a) => getAchLaneId(a) === "unassigned").sort((a, b) => a.sortOrder - b.sortOrder);
+    byLane.set("unassigned", unassigned.map((a) => `ach:${a._id}`));
+    setAchOrderByLane(byLane);
+    setPendingChanges([]);
+    setLocalAchFields(/* @__PURE__ */ new Map());
+    setLocalTrackFields(/* @__PURE__ */ new Map());
+  }, [tracks, achievements]);
+  const pushUndo = useCallback2(() => {
+    undoStack.current = [...undoStack.current.slice(-19), {
+      trackOrder,
+      achOrderByLane: new Map(achOrderByLane),
+      localAchFields: new Map(localAchFields),
+      localTrackFields: new Map(localTrackFields),
+      pendingChanges: [...pendingChanges]
+    }];
+  }, [trackOrder, achOrderByLane, localAchFields, localTrackFields, pendingChanges]);
+  const undo = useCallback2(() => {
+    const entry = undoStack.current.pop();
+    if (!entry) return;
+    setTrackOrder(entry.trackOrder);
+    setAchOrderByLane(entry.achOrderByLane);
+    setLocalAchFields(entry.localAchFields);
+    setLocalTrackFields(entry.localTrackFields);
+    setPendingChanges(entry.pendingChanges);
+  }, []);
+  const getAchievement = useCallback2((id) => {
+    const base = achievements.find((a) => a._id === id);
+    if (!base) return void 0;
+    const overrides = localAchFields.get(id);
+    return overrides ? { ...base, ...overrides } : base;
+  }, [achievements, localAchFields]);
+  const getTrack = useCallback2((id) => {
+    const base = tracks.find((t) => t._id === id);
+    if (!base) return void 0;
+    const overrides = localTrackFields.get(id);
+    return overrides ? { ...base, ...overrides } : base;
+  }, [tracks, localTrackFields]);
+  const getAchievementsForLane = useCallback2((laneId) => {
+    const ids = achOrderByLane.get(laneId) ?? [];
+    return ids.map((dndId) => {
+      const { rawId } = parseDndId2(dndId);
+      return getAchievement(rawId);
+    }).filter((a) => Boolean(a));
+  }, [achOrderByLane, getAchievement]);
+  const findLaneForAch = useCallback2((achDndId) => {
+    for (const [laneId, ids] of achOrderByLane) {
+      if (ids.includes(achDndId)) return laneId;
+    }
+    return void 0;
+  }, [achOrderByLane]);
+  const updateAchField = useCallback2((id, fields) => {
+    pushUndo();
+    setLocalAchFields((m) => {
+      const next = new Map(m);
+      next.set(id, { ...next.get(id) ?? {}, ...fields });
+      return next;
+    });
+    setPendingChanges((p) => [...p, { kind: "ach-field", id, fields }]);
+    if ("trackId" in fields) {
+      const achDndId = `ach:${id}`;
+      const newLane = fields.trackId ? `track:${fields.trackId}` : "unassigned";
+      setAchOrderByLane((prev) => {
+        const next = new Map(prev);
+        for (const [laneId, ids] of next) {
+          if (ids.includes(achDndId)) {
+            next.set(laneId, ids.filter((aid) => aid !== achDndId));
+            break;
+          }
+        }
+        const target = next.get(newLane) ?? [];
+        if (!target.includes(achDndId)) next.set(newLane, [...target, achDndId]);
+        return next;
+      });
+    }
+  }, [pushUndo]);
+  const updateTrackField = useCallback2((id, fields) => {
+    pushUndo();
+    setLocalTrackFields((m) => {
+      const next = new Map(m);
+      next.set(id, { ...next.get(id) ?? {}, ...fields });
+      return next;
+    });
+    setPendingChanges((p) => [...p, { kind: "track-field", id, fields }]);
+  }, [pushUndo]);
+  const handleDragStart = useCallback2((id) => {
+    setActiveDragId(id);
+  }, []);
+  const handleDragOver = useCallback2((event) => {
+    const { active, over } = event;
+    if (!over) return;
+    const activeId = String(active.id);
+    const overId = String(over.id);
+    const { type: activeType } = parseDndId2(activeId);
+    if (activeType !== "ach") return;
+    const sourceLane = findLaneForAch(activeId);
+    if (!sourceLane) return;
+    let targetLane;
+    const normalizedOverId = normalizeLaneId2(overId);
+    const { type: overType } = parseDndId2(normalizedOverId);
+    if (overType === "track" || normalizedOverId === "unassigned") targetLane = normalizedOverId;
+    else if (overType === "ach") targetLane = findLaneForAch(normalizedOverId) ?? sourceLane;
+    else return;
+    if (sourceLane === targetLane) return;
+    if (groupMode === "source") return;
+    setAchOrderByLane((prev) => {
+      const next = new Map(prev);
+      const srcList = (next.get(sourceLane) ?? []).filter((id) => id !== activeId);
+      const tgtList = [...next.get(targetLane) ?? [], activeId];
+      next.set(sourceLane, srcList);
+      next.set(targetLane, tgtList);
+      return next;
+    });
+  }, [findLaneForAch, groupMode]);
+  const handleDragEnd = useCallback2((event) => {
+    const { active, over } = event;
+    setActiveDragId(null);
+    if (!over) return;
+    const activeId = String(active.id);
+    const overId = String(over.id);
+    const { type: activeType, rawId: activeRawId } = parseDndId2(activeId);
+    if (activeType === "track") {
+      if (activeId === overId) return;
+      pushUndo();
+      setTrackOrder(arrayMove2(trackOrder, trackOrder.indexOf(activeId), trackOrder.indexOf(overId)));
+      setPendingChanges((p) => [...p, { kind: "track-reorder" }]);
+      return;
+    }
+    if (activeType === "ach") {
+      const lane = findLaneForAch(activeId);
+      if (!lane) return;
+      const laneIds = achOrderByLane.get(lane) ?? [];
+      const overIsInSameLane = laneIds.includes(overId);
+      if (!overIsInSameLane) {
+        const finalLane = findLaneForAch(activeId);
+        if (finalLane) {
+          pushUndo();
+          setPendingChanges((p) => [...p, { kind: "ach-reorder", laneId: finalLane }]);
+          if (finalLane !== "unassigned") {
+            const track = tracks.find((t) => `track:${t._id}` === finalLane);
+            if (track) updateAchField(activeRawId, { trackId: track._id });
+          } else {
+            updateAchField(activeRawId, { trackId: null });
+          }
+        }
+        return;
+      }
+      if (activeId === overId) return;
+      pushUndo();
+      const newLaneIds = arrayMove2(laneIds, laneIds.indexOf(activeId), laneIds.indexOf(overId));
+      setAchOrderByLane((prev) => {
+        const next = new Map(prev);
+        next.set(lane, newLaneIds);
+        return next;
+      });
+      setPendingChanges((p) => [...p, { kind: "ach-reorder", laneId: lane }]);
+    }
+  }, [trackOrder, achOrderByLane, tracks, findLaneForAch, pushUndo, updateAchField]);
+  const reset = useCallback2(() => {
+    const sortedTracks = [...tracks].sort((a, b) => a.sortOrder - b.sortOrder);
+    setTrackOrder(sortedTracks.map((t) => `track:${t._id}`));
+    const byLane = /* @__PURE__ */ new Map();
+    for (const t of sortedTracks) {
+      const laneId = `track:${t._id}`;
+      byLane.set(laneId, achievements.filter((a) => getAchLaneId(a) === laneId).sort((a, b) => a.sortOrder - b.sortOrder).map((a) => `ach:${a._id}`));
+    }
+    byLane.set("unassigned", achievements.filter((a) => getAchLaneId(a) === "unassigned").sort((a, b) => a.sortOrder - b.sortOrder).map((a) => `ach:${a._id}`));
+    setAchOrderByLane(byLane);
+    setPendingChanges([]);
+    setLocalAchFields(/* @__PURE__ */ new Map());
+    setLocalTrackFields(/* @__PURE__ */ new Map());
+    undoStack.current = [];
+  }, [tracks, achievements]);
+  const selectItem = useCallback2((item) => {
+    setSelectedItem(item);
+    if (item) setActivePanelTab("settings");
+  }, []);
+  const orderedTracks = useMemo2(() => {
+    return trackOrder.map((dndId) => {
+      const { rawId } = parseDndId2(dndId);
+      return getTrack(rawId);
+    }).filter((t) => Boolean(t));
+  }, [trackOrder, getTrack]);
+  return {
+    orderedTracks,
+    getAchievementsForLane,
+    getAchievement,
+    getTrack,
+    trackOrder,
+    achOrderByLane,
+    groupMode,
+    setGroupMode,
+    activeDragId,
+    handleDragStart,
+    handleDragOver,
+    handleDragEnd,
+    selectedItem,
+    selectItem,
+    activePanelTab,
+    setActivePanelTab,
+    updateAchField,
+    updateTrackField,
+    undo,
+    pendingChanges,
+    hasPendingChanges: pendingChanges.length > 0,
+    clearPendingChanges: () => setPendingChanges([]),
+    reset
+  };
+}
+
+// src/hooks/useTestMode.ts
+import { useState as useState3, useCallback as useCallback3 } from "react";
+function computeQuestTestState(quest, state, allQuests) {
+  if (state.completedIds.has(quest._id)) return "passed";
+  if (state.verifyingId === quest._id) return "verifying";
+  if (state.failedIds.has(quest._id)) return "failed";
+  if (quest.status !== "ACTIVE") return "locked";
+  if (state.ignoreChain) return "ready";
+  const prereqs = quest.prerequisites ?? [];
+  for (const prereqId of prereqs) {
+    if (!state.completedIds.has(prereqId)) return "locked";
+  }
+  const chains = quest.chains ?? {};
+  for (const [group, order] of Object.entries(chains)) {
+    if (order <= 0) continue;
+    const prevOrder = order - 1;
+    const prevQuests = allQuests.filter(
+      (q) => ((q.chains ?? {})[group] ?? -1) === prevOrder
+    );
+    for (const pq of prevQuests) {
+      if (!state.completedIds.has(pq._id)) return "locked";
+    }
+  }
+  return "ready";
+}
+function useTestMode(verifyFn) {
+  const [state, setState] = useState3({
+    active: false,
+    withVerification: false,
+    ignoreChain: false,
+    completedIds: /* @__PURE__ */ new Set(),
+    verifyingId: null,
+    failedIds: /* @__PURE__ */ new Map()
+  });
+  const enterTestMode = useCallback3(() => {
+    setState((s) => ({ ...s, active: true, completedIds: /* @__PURE__ */ new Set(), verifyingId: null, failedIds: /* @__PURE__ */ new Map() }));
+  }, []);
+  const exitTestMode = useCallback3(() => {
+    setState((s) => ({ ...s, active: false, completedIds: /* @__PURE__ */ new Set(), verifyingId: null, failedIds: /* @__PURE__ */ new Map() }));
+  }, []);
+  const toggleVerification = useCallback3(() => {
+    setState((s) => ({ ...s, withVerification: !s.withVerification }));
+  }, []);
+  const toggleIgnoreChain = useCallback3(() => {
+    setState((s) => ({ ...s, ignoreChain: !s.ignoreChain }));
+  }, []);
+  const claimQuest = useCallback3(async (questId) => {
+    if (!state.active) return;
+    if (!state.withVerification || !verifyFn) {
+      setState((s) => {
+        const next = new Set(s.completedIds);
+        next.add(questId);
+        return { ...s, completedIds: next };
+      });
+      return;
+    }
+    setState((s) => ({ ...s, verifyingId: questId }));
+    try {
+      const result = await verifyFn(questId);
+      setState((s) => {
+        if (result.passed) {
+          const next = new Set(s.completedIds);
+          next.add(questId);
+          return { ...s, verifyingId: null, completedIds: next };
+        } else {
+          const nextFailed = new Map(s.failedIds);
+          nextFailed.set(questId, result.reason ?? "Verification failed");
+          return { ...s, verifyingId: null, failedIds: nextFailed };
+        }
+      });
+    } catch {
+      setState((s) => {
+        const nextFailed = new Map(s.failedIds);
+        nextFailed.set(questId, "Network error");
+        return { ...s, verifyingId: null, failedIds: nextFailed };
+      });
+    }
+  }, [state.active, state.withVerification, verifyFn]);
+  const resetTest = useCallback3(() => {
+    setState((s) => ({ ...s, completedIds: /* @__PURE__ */ new Set(), verifyingId: null, failedIds: /* @__PURE__ */ new Map() }));
+  }, []);
+  return {
+    testMode: state,
+    enterTestMode,
+    exitTestMode,
+    toggleVerification,
+    toggleIgnoreChain,
+    claimQuest,
+    resetTest
+  };
+}
+
+// src/hooks/useChainMode.ts
+import { useState as useState4, useMemo as useMemo3, useCallback as useCallback4 } from "react";
+function useChainMode(items) {
+  const [active, setActive] = useState4(false);
+  const [selectedChain, setSelectedChain] = useState4(null);
+  const chainMap = useMemo3(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const q of items) {
+      const chains = q.chains ?? {};
+      for (const group of Object.keys(chains)) {
+        const list = map.get(group) ?? [];
+        list.push(q);
+        map.set(group, list);
+      }
+    }
+    for (const [group, list] of map) {
+      list.sort((a, b) => ((a.chains ?? {})[group] ?? 0) - ((b.chains ?? {})[group] ?? 0));
+    }
+    return map;
+  }, [items]);
+  const chainGroups = useMemo3(
+    () => [...chainMap.keys()].sort(),
+    [chainMap]
+  );
+  const toggle = useCallback4(() => {
+    setActive((prev) => {
+      if (prev) setSelectedChain(null);
+      return !prev;
+    });
+  }, []);
+  const selectChain = useCallback4((group) => {
+    setSelectedChain(group);
+  }, []);
+  const deselectChain = useCallback4(() => {
+    setSelectedChain(null);
+  }, []);
+  const exit = useCallback4(() => {
+    setActive(false);
+    setSelectedChain(null);
+  }, []);
+  return {
+    active,
+    selectedChain,
+    toggle,
+    selectChain,
+    deselectChain,
+    exit,
+    chainMap,
+    chainGroups
+  };
+}
+
+// src/hooks/useAchievementTestMode.ts
+import { useState as useState5, useCallback as useCallback5 } from "react";
+function computeAchTestState(ach, state, allAchievements) {
+  const progress = state.progressMap.get(ach._id);
+  if (progress?.claimed) return "claimed";
+  if (progress?.completed) return "completed";
+  if (ach.status !== "ACTIVE") return "locked";
+  if (state.ignoreChain) return "ready";
+  const chains = ach.chains ?? {};
+  for (const [group, order] of Object.entries(chains)) {
+    if (order <= 0) continue;
+    const prevOrder = order - 1;
+    const prevAchs = allAchievements.filter(
+      (a) => ((a.chains ?? {})[group] ?? -1) === prevOrder
+    );
+    for (const pa of prevAchs) {
+      const pp = state.progressMap.get(pa._id);
+      if (!pp?.completed) return "locked";
+    }
+  }
+  return "ready";
+}
+function useAchievementTestMode(fetchProgressFn) {
+  const [state, setState] = useState5({
+    active: false,
+    walletAddress: "",
+    ignoreChain: false,
+    progressMap: /* @__PURE__ */ new Map(),
+    loading: false,
+    error: null
+  });
+  const enterTestMode = useCallback5(() => {
+    setState((s) => ({ ...s, active: true, progressMap: /* @__PURE__ */ new Map(), error: null }));
+  }, []);
+  const exitTestMode = useCallback5(() => {
+    setState((s) => ({ ...s, active: false, walletAddress: "", progressMap: /* @__PURE__ */ new Map(), loading: false, error: null }));
+  }, []);
+  const toggleIgnoreChain = useCallback5(() => {
+    setState((s) => ({ ...s, ignoreChain: !s.ignoreChain }));
+  }, []);
+  const setWalletAddress = useCallback5((address) => {
+    setState((s) => ({ ...s, walletAddress: address }));
+  }, []);
+  const fetchProgress = useCallback5(async (address) => {
+    const wallet = address ?? state.walletAddress;
+    if (!wallet.trim() || !fetchProgressFn) return;
+    setState((s) => ({ ...s, loading: true, error: null, walletAddress: wallet }));
+    try {
+      const progress = await fetchProgressFn(wallet.trim());
+      const map = /* @__PURE__ */ new Map();
+      for (const p of progress) {
+        map.set(p.achievementId, p);
+      }
+      setState((s) => ({ ...s, progressMap: map, loading: false }));
+    } catch (err) {
+      setState((s) => ({
+        ...s,
+        loading: false,
+        error: err instanceof Error ? err.message : String(err)
+      }));
+    }
+  }, [state.walletAddress, fetchProgressFn]);
+  const clearProgress = useCallback5(() => {
+    setState((s) => ({ ...s, progressMap: /* @__PURE__ */ new Map(), walletAddress: "", error: null }));
+  }, []);
+  return {
+    testMode: state,
+    enterTestMode,
+    exitTestMode,
+    toggleIgnoreChain,
+    setWalletAddress,
+    fetchProgress,
+    clearProgress
+  };
+}
+
+// src/hooks/useAchievementChainMode.ts
+import { useState as useState6, useMemo as useMemo4, useCallback as useCallback6 } from "react";
+function useAchievementChainMode(achievements) {
+  const [active, setActive] = useState6(false);
+  const [selectedChain, setSelectedChain] = useState6(null);
+  const chainMap = useMemo4(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const a of achievements) {
+      const chains = a.chains ?? {};
+      for (const group of Object.keys(chains)) {
+        const list = map.get(group) ?? [];
+        list.push(a);
+        map.set(group, list);
+      }
+    }
+    for (const [group, list] of map) {
+      list.sort((a, b) => ((a.chains ?? {})[group] ?? 0) - ((b.chains ?? {})[group] ?? 0));
+    }
+    return map;
+  }, [achievements]);
+  const chainGroups = useMemo4(
+    () => [...chainMap.keys()].sort(),
+    [chainMap]
+  );
+  const toggle = useCallback6(() => {
+    setActive((prev) => {
+      if (prev) setSelectedChain(null);
+      return !prev;
+    });
+  }, []);
+  const selectChain = useCallback6((group) => {
+    setSelectedChain(group);
+  }, []);
+  const deselectChain = useCallback6(() => {
+    setSelectedChain(null);
+  }, []);
+  const exit = useCallback6(() => {
+    setActive(false);
+    setSelectedChain(null);
+  }, []);
+  return {
+    active,
+    selectedChain,
+    toggle,
+    selectChain,
+    deselectChain,
+    exit,
+    chainMap,
+    chainGroups
+  };
+}
+export {
+  chainColor,
+  computeAchTestState,
+  computeQuestTestState,
+  getAchLaneId,
+  getLaneId,
+  useAchievementCanvasState,
+  useAchievementChainMode,
+  useAchievementTestMode,
+  useCanvasState,
+  useChainMode,
+  useTestMode
+};