@ixo/editor 6.33.0 → 6.34.0

package/dist/ClaimFlowDetail-UVEQMEI5.js

@@ -0,0 +1,641 @@
+import {
+  StableSurvey
+} from "./chunk-2GAYKKTL.js";
+import {
+  resolveFilesInCredentialSubject
+} from "./chunk-OMLI45ER.js";
+import {
+  parseClaimActionInputs
+} from "./chunk-ZUATADUV.js";
+import {
+  ActAsGroupSection,
+  GroupProposalStatus,
+  actAsGroupReady,
+  actAsGroupRuntimeInputs,
+  emptyActAsGroupState
+} from "./chunk-2WPEATI7.js";
+import "./chunk-TR4KO3AG.js";
+import {
+  SurveyAiFillButton,
+  attachSurveyAnalytics,
+  buildBlockLabel,
+  getFlowRoomContext,
+  useRegisterOpenSurvey
+} from "./chunk-PFF6VY35.js";
+import {
+  surveyTheme
+} from "./chunk-MHM52LCJ.js";
+import {
+  getClaimStatusInfo
+} from "./chunk-NKE4TL43.js";
+import {
+  ListItemContainer
+} from "./chunk-EYKZIZ5J.js";
+import "./chunk-BZ7UPUTY.js";
+import {
+  BasePrimaryButton
+} from "./chunk-K74XQ4Q5.js";
+import "./chunk-4NAFQF6V.js";
+import {
+  useRunRuntimeReader
+} from "./chunk-FFYZXA75.js";
+import "./chunk-NZ7AXA7B.js";
+import "./chunk-HRRI4BLF.js";
+import "./chunk-F4PTFXZH.js";
+import "./chunk-IH4T7V4C.js";
+import "./chunk-PYNDJDWZ.js";
+import "./chunk-NIXT2SBH.js";
+import "./chunk-JIDTNKKL.js";
+import {
+  resolveReferences
+} from "./chunk-JVROGQ7Q.js";
+import "./chunk-IIIZZ4E4.js";
+import "./chunk-HT6L7A5M.js";
+import "./chunk-RRYBAE6E.js";
+import "./chunk-N3ORMGAI.js";
+import "./chunk-NCSGIRRQ.js";
+import "./chunk-ZDNW6VQG.js";
+import {
+  DismissibleAlert
+} from "./chunk-IFWKRCFF.js";
+import {
+  actionAlertStyles
+} from "./chunk-6GKJR52N.js";
+import "./chunk-EBFFDDAS.js";
+import "./chunk-WO7V6ZNC.js";
+import {
+  useBlocknoteHandlers,
+  useTranslate
+} from "./chunk-4DGCCXD6.js";
+import "./chunk-7W7UUUIE.js";
+import "./chunk-TS2LNBF2.js";
+
+// src/mantine/blocks/action/actionTypes/claim/ClaimFlowDetail.tsx
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { ActionIcon, Box, Collapse, Group, Loader, Stack, Text, UnstyledButton } from "@mantine/core";
+import { IconArrowLeft, IconCheck, IconChevronRight, IconPlayerPlay } from "@tabler/icons-react";
+import { SurveyModel } from "@ixo/surveys";
+function getTimeAgo(dateString) {
+  if (!dateString) return "";
+  try {
+    const date = new Date(dateString);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 6e4);
+    if (diffMins < 1) return "just now";
+    if (diffMins < 60) return `${diffMins}m ago`;
+    const diffHours = Math.floor(diffMins / 60);
+    if (diffHours < 24) return `${diffHours}h ago`;
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays < 30) return `${diffDays} day${diffDays > 1 ? "s" : ""} ago`;
+    const diffMonths = Math.floor(diffDays / 30);
+    return `${diffMonths} month${diffMonths > 1 ? "s" : ""} ago`;
+  } catch {
+    return dateString;
+  }
+}
+function truncateAddress(address) {
+  if (!address) return "";
+  if (address.length <= 14) return address;
+  return `${address.slice(0, 8)}...${address.slice(-3)}`;
+}
+function truncateId(value, start = 8, end = 6) {
+  if (!value) return "";
+  if (value.length <= start + end + 3) return value;
+  return `${value.slice(0, start)}...${value.slice(-end)}`;
+}
+var ClaimFlowDetail = ({
+  inputs,
+  editor,
+  runtime,
+  block,
+  isDisabled,
+  provideSigningHandler,
+  unlockSigning,
+  registerRuntimeInputs,
+  executeAction
+}) => {
+  const [actAs, setActAs] = useState(emptyActAsGroupState());
+  const t = useTranslate();
+  const handlers = useBlocknoteHandlers();
+  const handlersRef = useRef(handlers);
+  useEffect(() => {
+    handlersRef.current = handlers;
+  }, [handlers]);
+  const actorDid = useMemo(() => {
+    try {
+      return handlers?.getCurrentUser?.()?.address || "";
+    } catch {
+      return "";
+    }
+  }, [handlers]);
+  const parsed = useMemo(() => parseClaimActionInputs(inputs), [inputs]);
+  const editorDocument = editor?.document || [];
+  const runtimeReader = useRunRuntimeReader(editor);
+  const resolveOpts = useMemo(() => ({ yRuntime: runtimeReader }), [runtimeReader]);
+  const deedDid = resolveReferences(parsed.deedDid, editorDocument, resolveOpts).trim();
+  const collectionId = resolveReferences(parsed.collectionId, editorDocument, resolveOpts).trim();
+  const [claims, setClaims] = useState([]);
+  const [loadingClaims, setLoadingClaims] = useState(false);
+  const [adminAddress, setAdminAddress] = useState("");
+  const [surveyJson, setSurveyJson] = useState(null);
+  const [prefillData, setPrefillData] = useState(null);
+  const [loadingSurvey, setLoadingSurvey] = useState(false);
+  const [submitting, setSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+  const [profilesByDid, setProfilesByDid] = useState({});
+  const [isServiceAgentAuthorized, setIsServiceAgentAuthorized] = useState(false);
+  const [authChecking, setAuthChecking] = useState(true);
+  const [authError, setAuthError] = useState(null);
+  const [authRetryKey, setAuthRetryKey] = useState(0);
+  const [surveyComplete, setSurveyComplete] = useState(false);
+  const [selectedClaimId, setSelectedClaimId] = useState("");
+  const [selectedClaimData, setSelectedClaimData] = useState(null);
+  const [loadingClaimDetail, setLoadingClaimDetail] = useState(false);
+  const [disputeDetails, setDisputeDetails] = useState(null);
+  const [loadingDispute, setLoadingDispute] = useState(false);
+  const [claimsExpanded, setClaimsExpanded] = useState(false);
+  const selectedClaim = useMemo(() => claims.find((c) => c.claimId === selectedClaimId) || null, [claims, selectedClaimId]);
+  const selectedClaimStatus = useMemo(() => selectedClaim ? getClaimStatusInfo(selectedClaim) : null, [selectedClaim]);
+  const isSelectedDisputed = selectedClaimStatus?.key === "disputed";
+  const checkSurveyCompleteness = useCallback((model) => {
+    const allRequired = model.getAllQuestions(true).filter((q) => q.isRequired);
+    const isComplete = allRequired.length === 0 || allRequired.every((q) => !q.isEmpty());
+    setSurveyComplete(isComplete);
+  }, []);
+  const surveyModel = useMemo(() => {
+    if (!surveyJson) return null;
+    const model = new SurveyModel(surveyJson);
+    model.applyTheme(surveyTheme);
+    model.showQuestionNumbers = "off";
+    if (provideSigningHandler) {
+      model.showCompleteButton = false;
+      model.showCompletedPage = false;
+      const reviewEl = model.getQuestionByName("reviewAndSubmit") || model.getPanelByName("reviewAndSubmit");
+      if (reviewEl) reviewEl.visible = false;
+      const reviewMsg = model.getQuestionByName("reviewMessage");
+      if (reviewMsg) reviewMsg.visible = false;
+    }
+    if (handlersRef.current.uploadClaimFile) {
+      for (const q of model.getAllQuestions()) {
+        if (q.getType?.() === "file") {
+          q.storeDataAsText = false;
+        }
+      }
+      model.onUploadFiles.add((_sender, options) => {
+        const uploader = handlersRef.current.uploadClaimFile;
+        if (!uploader) {
+          options.callback([], ["File upload is not supported"]);
+          return;
+        }
+        Promise.all(options.files.map((file) => uploader(file, collectionId, { entityDid: deedDid }))).then((results) => {
+          options.callback(options.files.map((file, i) => ({ file, content: results[i].content })));
+        }).catch((err) => {
+          console.error("[Claim] file upload failed", err);
+          options.callback([], [err instanceof Error ? err.message : "File upload failed"]);
+        });
+      });
+    }
+    if (prefillData) {
+      model.data = prefillData?.credentialSubject ?? prefillData;
+    }
+    return model;
+  }, [surveyJson, provideSigningHandler, prefillData, collectionId, deedDid]);
+  const mediaBlobCacheRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    return () => {
+      for (const blobUrl of mediaBlobCacheRef.current.values()) URL.revokeObjectURL(blobUrl);
+      mediaBlobCacheRef.current.clear();
+    };
+  }, []);
+  const detailSurveyModel = useMemo(() => {
+    if (!surveyJson || !selectedClaimData) return null;
+    const model = new SurveyModel(surveyJson);
+    model.applyTheme(surveyTheme);
+    model.showQuestionNumbers = "off";
+    model.questionsOnPageMode = "singlePage";
+    model.mode = "display";
+    const fetcher = handlersRef.current.fetchClaimMedia;
+    if (fetcher) {
+      const cache = mediaBlobCacheRef.current;
+      for (const q of model.getAllQuestions()) {
+        if (q.getType?.() === "file") {
+          q.storeDataAsText = false;
+        }
+      }
+      model.onDownloadFile.add((_sender, options) => {
+        const src = options?.content;
+        if (typeof src !== "string" || !/^https?:/i.test(src)) {
+          options.callback("success", src);
+          return;
+        }
+        const cached = cache.get(src);
+        if (cached) {
+          options.callback("success", cached);
+          return;
+        }
+        fetcher(src, { entityDid: deedDid }).then((blob) => {
+          const blobUrl = URL.createObjectURL(blob);
+          cache.set(src, blobUrl);
+          options.callback("success", blobUrl);
+        }).catch((err) => {
+          console.error("[Claim] fetchClaimMedia failed", src, err);
+          options.callback("error");
+        });
+      });
+    }
+    const cs = selectedClaimData?.credentialSubject ?? selectedClaimData;
+    model.data = cs && typeof cs === "object" ? resolveFilesInCredentialSubject(cs) : cs;
+    return model;
+  }, [surveyJson, selectedClaimData, deedDid]);
+  const openSurveyId = `claim-action:${block.id}:new`;
+  const openSurveyTitle = `Submit Claim${block?.props?.title ? ` \u2014 ${block.props.title}` : ""}`;
+  useRegisterOpenSurvey({
+    id: openSurveyId,
+    title: openSurveyTitle,
+    source: "panel",
+    schema: surveyJson,
+    context: {
+      flowType: "claim-submission",
+      blockId: block.id,
+      blockTitle: block?.props?.title,
+      blockType: "action",
+      deedId: deedDid,
+      collectionId,
+      ...getFlowRoomContext(editor)
+    },
+    model: surveyModel,
+    enabled: !!surveyModel && !selectedClaimId
+  });
+  useEffect(() => {
+    if (!registerRuntimeInputs) return;
+    registerRuntimeInputs({ adminAddress, claimStarted: !!surveyJson && !selectedClaimId });
+  }, [registerRuntimeInputs, adminAddress, surveyJson, selectedClaimId]);
+  useEffect(() => {
+    if (!unlockSigning) return;
+    unlockSigning((actAs.actAsGroup || isServiceAgentAuthorized) && !!surveyModel && !!adminAddress && surveyComplete && !selectedClaimId && actAsGroupReady(actAs));
+  }, [unlockSigning, isServiceAgentAuthorized, surveyModel, adminAddress, surveyComplete, selectedClaimId, actAs]);
+  useEffect(() => {
+    if (!surveyModel) {
+      setSurveyComplete(false);
+      return;
+    }
+    const handler = () => checkSurveyCompleteness(surveyModel);
+    surveyModel.onValueChanged.add(handler);
+    surveyModel.onCurrentPageChanged.add(handler);
+    checkSurveyCompleteness(surveyModel);
+    return () => {
+      surveyModel.onValueChanged.remove(handler);
+      surveyModel.onCurrentPageChanged.remove(handler);
+    };
+  }, [surveyModel, checkSurveyCompleteness]);
+  useEffect(() => {
+    if (!provideSigningHandler || !surveyModel) return;
+    provideSigningHandler(async () => {
+      surveyModel.tryComplete();
+    });
+  }, [provideSigningHandler, surveyModel]);
+  const fetchClaimsAndAdmin = useCallback(async () => {
+    if (!deedDid || !collectionId || !actorDid) return;
+    const handlers2 = handlersRef.current;
+    setLoadingClaims(true);
+    setError(null);
+    try {
+      const [claimsResponse, collectionsResponse] = await Promise.all([
+        handlers2.getClaimsPerUserAddress({ collectionId, userAddress: actorDid }),
+        handlers2.getClaimCollections(deedDid)
+      ]);
+      const fetchedClaims = Array.isArray(claimsResponse) ? claimsResponse : [];
+      console.log(
+        "[Claim/SA] status breakdown:",
+        fetchedClaims.map((c) => ({
+          claimId: c.claimId,
+          evalStatus: c.evaluationByClaimId?.status,
+          disputeBySubjectId: c.disputeBySubjectId,
+          resolvedKey: getClaimStatusInfo(c).key
+        }))
+      );
+      setClaims(fetchedClaims);
+      const resolvedAdmin = collectionsResponse?.collections?.find?.((c) => c?.id === collectionId)?.admin || collectionsResponse?.adminAddress || "";
+      setAdminAddress(resolvedAdmin);
+    } catch (err) {
+      setClaims([]);
+      setAdminAddress("");
+      setError(err instanceof Error ? err.message : t("actionTypes.claim.flow.errors.loadClaimData", { defaultValue: "Failed to load claim data" }));
+    } finally {
+      setLoadingClaims(false);
+    }
+  }, [deedDid, collectionId, actorDid]);
+  useEffect(() => {
+    setSurveyJson(null);
+    setPrefillData(null);
+    setSelectedClaimId("");
+    setError(null);
+  }, [deedDid, collectionId]);
+  useEffect(() => {
+    if (!deedDid || !collectionId || !actorDid) return;
+    fetchClaimsAndAdmin();
+  }, [deedDid, collectionId, actorDid, fetchClaimsAndAdmin]);
+  useEffect(() => {
+    let mounted = true;
+    const dids = Array.from(new Set(claims.map((claim) => claim.agentDid).filter(Boolean)));
+    const missing = dids.filter((did) => !profilesByDid[did]);
+    if (missing.length === 0)
+      return () => {
+        mounted = false;
+      };
+    const loadProfiles = async () => {
+      const handlers2 = handlersRef.current;
+      const results = await Promise.all(
+        missing.map(async (did) => {
+          try {
+            const profile = await handlers2.getMatrixInfoPerDid(did);
+            return [did, profile];
+          } catch {
+            return [did, null];
+          }
+        })
+      );
+      if (!mounted) return;
+      setProfilesByDid((prev) => {
+        const next = { ...prev };
+        results.forEach(([did, profile]) => {
+          if (profile) {
+            next[did] = profile;
+          }
+        });
+        return next;
+      });
+    };
+    loadProfiles();
+    return () => {
+      mounted = false;
+    };
+  }, [claims, profilesByDid]);
+  useEffect(() => {
+    let mounted = true;
+    const checkServiceAgentAuthorization = async () => {
+      const handlers2 = handlersRef.current;
+      if (!deedDid || !collectionId || !adminAddress || !actorDid) {
+        if (mounted) {
+          setIsServiceAgentAuthorized(false);
+          setAuthError(null);
+          setAuthChecking(false);
+        }
+        return;
+      }
+      if (typeof handlers2.getUserRoles !== "function") {
+        if (mounted) {
+          setIsServiceAgentAuthorized(false);
+          setAuthError(null);
+          setAuthChecking(false);
+        }
+        return;
+      }
+      setAuthChecking(true);
+      setAuthError(null);
+      try {
+        const roles = await handlers2.getUserRoles({
+          userAddress: actorDid,
+          adminAddress,
+          deedDid,
+          collectionIds: [collectionId]
+        });
+        const role = roles?.find((r) => r.collectionId === collectionId)?.role || null;
+        if (mounted) {
+          setIsServiceAgentAuthorized(role === "SA" /* ServiceProvider */);
+          setAuthError(null);
+        }
+      } catch (err) {
+        if (mounted) {
+          setIsServiceAgentAuthorized(false);
+          setAuthError(err instanceof Error ? err.message : t("actionTypes.claim.flow.errors.verifyAuth", { defaultValue: "Failed to verify authorization" }));
+        }
+      } finally {
+        if (mounted) {
+          setAuthChecking(false);
+        }
+      }
+    };
+    checkServiceAgentAuthorization();
+    return () => {
+      mounted = false;
+    };
+  }, [actorDid, adminAddress, deedDid, collectionId, authRetryKey]);
+  useEffect(() => {
+    if (!selectedClaim) {
+      setSelectedClaimData(null);
+      setDisputeDetails(null);
+      return;
+    }
+    let cancelled = false;
+    const loadDetail = async () => {
+      const handlers2 = handlersRef.current;
+      setLoadingClaimDetail(true);
+      setError(null);
+      try {
+        const [claimDataResult, templateResult] = await Promise.all([
+          handlers2.getClaimData(collectionId, selectedClaim.claimId, { entityDid: deedDid }),
+          surveyJson ? Promise.resolve({ surveyTemplate: surveyJson }) : handlers2.getDeedSurveyTemplate(deedDid, collectionId)
+        ]);
+        if (cancelled) return;
+        setSelectedClaimData(claimDataResult || null);
+        if (!surveyJson && templateResult?.surveyTemplate) {
+          setSurveyJson(templateResult.surveyTemplate);
+        }
+      } catch (err) {
+        if (!cancelled) setError(err instanceof Error ? err.message : t("actionTypes.claim.flow.errors.loadClaimDetails", { defaultValue: "Failed to load claim details" }));
+      } finally {
+        if (!cancelled) setLoadingClaimDetail(false);
+      }
+      if (getClaimStatusInfo(selectedClaim).key === "disputed" && typeof handlers2.getClaimDisputeDetails === "function") {
+        setLoadingDispute(true);
+        try {
+          const details = await handlers2.getClaimDisputeDetails(selectedClaim.claimId);
+          if (!cancelled) setDisputeDetails(details);
+        } catch {
+          if (!cancelled) setDisputeDetails(null);
+        } finally {
+          if (!cancelled) setLoadingDispute(false);
+        }
+      } else {
+        setDisputeDetails(null);
+      }
+    };
+    loadDetail();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedClaim, collectionId, deedDid, surveyJson]);
+  const amendAndResubmit = useCallback(() => {
+    if (!selectedClaimData) return;
+    setPrefillData(selectedClaimData);
+    setSelectedClaimId("");
+  }, [selectedClaimData]);
+  const startSurvey = useCallback(async () => {
+    if (!deedDid) return;
+    const handlers2 = handlersRef.current;
+    setLoadingSurvey(true);
+    setError(null);
+    setPrefillData(null);
+    try {
+      const template = await handlers2.getDeedSurveyTemplate(deedDid, collectionId);
+      if (!template?.surveyTemplate) {
+        setSurveyJson(null);
+        setError(t("actionTypes.claim.flow.errors.noSurveyTemplate", { defaultValue: "No survey template found for this {{did}}", did: "DID" }));
+        return;
+      }
+      setSurveyJson(template.surveyTemplate);
+    } catch (err) {
+      setSurveyJson(null);
+      setError(err instanceof Error ? err.message : t("actionTypes.shared.errors.surveyTemplateLoad", { defaultValue: "Failed to load survey template" }));
+    } finally {
+      setLoadingSurvey(false);
+    }
+  }, [deedDid, collectionId]);
+  const handleSurveyComplete = useCallback(
+    async (sender) => {
+      if (authChecking || !isServiceAgentAuthorized && !actAs.actAsGroup) {
+        setError(t("actionTypes.claim.flow.errors.notAuthorized", { defaultValue: "You need service agent authorization for this collection to submit claims." }));
+        return;
+      }
+      if (!adminAddress) {
+        setError(t("actionTypes.claim.flow.errors.noAdminAddress", { defaultValue: "Admin address could not be resolved for this collection" }));
+        return;
+      }
+      if (!executeAction) {
+        setError(t("actionTypes.claim.flow.errors.actionNotRegistered", { defaultValue: "Claim action executor is unavailable" }));
+        return;
+      }
+      const submissionProps = {
+        flowType: "claim-submission",
+        entityDid: handlers.getEntityDid?.(),
+        ...getFlowRoomContext(editor),
+        blockId: block.id,
+        blockTitle: block?.props?.title,
+        blockLabel: buildBlockLabel(block.id, block?.props?.title),
+        deedId: deedDid,
+        collectionId
+      };
+      let submittedEmitted = false;
+      setSubmitting(true);
+      setError(null);
+      try {
+        handlers.onAnalyticsEvent?.("editor_flow_submission_attempted", submissionProps);
+        const outcome = await executeAction({
+          runtimeInputs: {
+            ...actAsGroupRuntimeInputs(actAs),
+            deedDid,
+            collectionId,
+            adminAddress,
+            surveyAnswers: sender.data
+          }
+        });
+        if (!outcome.success) {
+          throw new Error(outcome.error || t("actionTypes.claim.flow.errors.executionFailed", { defaultValue: "Claim execution failed" }));
+        }
+        handlers.onAnalyticsEvent?.("editor_flow_submitted", {
+          ...submissionProps,
+          claimId: outcome.output?.claimId
+        });
+        submittedEmitted = true;
+        setSurveyJson(null);
+        setPrefillData(null);
+        setClaimsExpanded(true);
+        await fetchClaimsAndAdmin();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : t("actionTypes.claim.flow.errors.submitFailed", { defaultValue: "Failed to submit claim" });
+        if (!submittedEmitted) {
+          handlers.onAnalyticsEvent?.("editor_flow_submission_failed", { ...submissionProps, reason: message });
+        }
+        setError(message);
+      } finally {
+        setSubmitting(false);
+      }
+    },
+    [adminAddress, actorDid, block.id, collectionId, deedDid, editor, executeAction, fetchClaimsAndAdmin, handlers, authChecking, isServiceAgentAuthorized, actAs]
+  );
+  useEffect(() => {
+    if (!surveyModel) return void 0;
+    surveyModel.onComplete.add(handleSurveyComplete);
+    return () => {
+      surveyModel.onComplete.remove(handleSurveyComplete);
+    };
+  }, [surveyModel, handleSurveyComplete]);
+  useEffect(() => {
+    return attachSurveyAnalytics({
+      model: surveyModel,
+      handlers,
+      flowType: "claim-submission",
+      sectionName: "claim-survey",
+      extraProps: {
+        entityDid: handlers?.getEntityDid?.(),
+        ...getFlowRoomContext(editor),
+        blockId: block.id,
+        blockTitle: block?.props?.title,
+        blockLabel: buildBlockLabel(block.id, block?.props?.title),
+        deedId: deedDid,
+        collectionId
+      }
+    });
+  }, [surveyModel, handlers, editor, deedDid, collectionId, block.id, block?.props?.title]);
+  if (selectedClaim) {
+    return /* @__PURE__ */ React.createElement(Stack, { gap: "md" }, /* @__PURE__ */ React.createElement(Group, { gap: "xs", align: "center" }, /* @__PURE__ */ React.createElement(ActionIcon, { variant: "subtle", color: "gray", size: "sm", onClick: () => setSelectedClaimId("") }, /* @__PURE__ */ React.createElement(IconArrowLeft, { size: 16 })), /* @__PURE__ */ React.createElement(Text, { fw: 500, size: "sm", title: selectedClaim.claimId }, t("actionTypes.claim.flow.claimNumber", { id: truncateId(selectedClaim.claimId), defaultValue: `Claim #${truncateId(selectedClaim.claimId)}` }))), selectedClaimStatus && /* @__PURE__ */ React.createElement(Group, { gap: "xs", align: "center" }, /* @__PURE__ */ React.createElement(Text, { size: "sm", c: "dimmed" }, t("actionTypes.claim.flow.statusLabel", { defaultValue: "Status:" })), /* @__PURE__ */ React.createElement(Text, { fw: 500, size: "sm", c: selectedClaimStatus.color }, selectedClaimStatus.label), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, "\xB7 ", getTimeAgo(selectedClaim.submissionDate || ""))), isSelectedDisputed && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "orange", title: t("actionTypes.claim.flow.disputed.title", { defaultValue: "Claim disputed" }), styles: actionAlertStyles }, loadingDispute ? /* @__PURE__ */ React.createElement(Group, { gap: "xs" }, /* @__PURE__ */ React.createElement(Loader, { size: "xs" }), /* @__PURE__ */ React.createElement(Text, { size: "xs" }, t("actionTypes.claim.flow.disputed.loadingDetails", { defaultValue: "Loading dispute details\u2026" }))) : disputeDetails ? /* @__PURE__ */ React.createElement(Stack, { gap: 6 }, disputeDetails.reason ? /* @__PURE__ */ React.createElement(Text, { size: "sm" }, disputeDetails.reason) : /* @__PURE__ */ React.createElement(Text, { size: "sm", c: "dimmed" }, t("actionTypes.claim.flow.disputed.noMessage", { defaultValue: "The evaluator disputed this claim but did not provide a message." })), (disputeDetails.evaluatorDid || disputeDetails.disputedAt) && /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, disputeDetails.evaluatorDid ? t("actionTypes.claim.flow.disputed.byEvaluator", {
+      address: truncateAddress(disputeDetails.evaluatorDid),
+      defaultValue: `By ${truncateAddress(disputeDetails.evaluatorDid)}`
+    }) : "", disputeDetails.evaluatorDid && disputeDetails.disputedAt ? " \xB7 " : "", disputeDetails.disputedAt ? new Date(disputeDetails.disputedAt).toLocaleString() : ""), /* @__PURE__ */ React.createElement(BasePrimaryButton, { onClick: amendAndResubmit, disabled: isDisabled || submitting || !isServiceAgentAuthorized || !selectedClaimData }, t("actionTypes.claim.flow.disputed.amendAndResubmit", { defaultValue: "Amend & Resubmit" }))) : typeof handlers.getClaimDisputeDetails !== "function" ? /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.disputed.unavailable", { defaultValue: "Dispute details unavailable in this environment." })) : /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.disputed.noRecord", { defaultValue: "No dispute record found on-chain for this claim." }))), loadingClaimDetail ? /* @__PURE__ */ React.createElement(Group, { gap: "xs" }, /* @__PURE__ */ React.createElement(Loader, { size: "xs" }), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.loadingSubmission", { defaultValue: "Loading submission\u2026" }))) : detailSurveyModel ? /* @__PURE__ */ React.createElement(StableSurvey, { model: detailSurveyModel }) : /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.noSubmissionData", { defaultValue: "No submission data available." })), error && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "red", styles: actionAlertStyles }, error));
+  }
+  return /* @__PURE__ */ React.createElement(Stack, { gap: "md" }, /* @__PURE__ */ React.createElement(GroupProposalStatus, { editor, block, runtime }), runtime?.state !== "awaiting_readback" && /* @__PURE__ */ React.createElement(
+    ActAsGroupSection,
+    {
+      value: actAs,
+      onChange: setActAs,
+      isDisabled,
+      actionLabel: "submit this claim",
+      authzFilter: collectionId ? { requiresAuthz: "submitClaim", collectionId } : void 0
+    }
+  ), !deedDid || !collectionId ? /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, t("actionTypes.shared.errors.configRequired", {
+    defaultValue: "Configure {{did}} and {{claimCollection}} in template mode before running this action.",
+    did: "DID",
+    claimCollection: "claim collection"
+  })) : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.shared.collectionPrefix", { id: collectionId, defaultValue: `Collection: ${collectionId}` })), loadingClaims ? /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.loadingYourClaims", { defaultValue: "Loading your claims..." })) : claims.length === 0 ? /* @__PURE__ */ React.createElement(Text, { size: "sm", c: "dimmed" }, t("actionTypes.claim.flow.noClaimsYet", { defaultValue: "No claims submitted for this collection yet." })) : /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(UnstyledButton, { onClick: () => setClaimsExpanded((prev) => !prev), style: { color: "var(--mantine-color-text)" } }, /* @__PURE__ */ React.createElement(Group, { gap: 6, align: "center" }, /* @__PURE__ */ React.createElement(IconChevronRight, { size: 16, style: { transform: claimsExpanded ? "rotate(90deg)" : "none", transition: "transform 150ms ease", flexShrink: 0 } }), /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600 }, t("actionTypes.claim.flow.yourClaims", { defaultValue: "Your Claims" }), " (", claims.length, ")"))), /* @__PURE__ */ React.createElement(Collapse, { in: claimsExpanded }, /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, claims.map((claim) => {
+    const status = getClaimStatusInfo(claim);
+    const profile = profilesByDid[claim.agentDid];
+    const displayName = profile?.displayname || claim.agentDid || claim.agentAddress;
+    const avatarLabel = (profile?.displayname || claim.agentDid || claim.agentAddress || "?")[0]?.toUpperCase();
+    return /* @__PURE__ */ React.createElement(ListItemContainer, { key: claim.claimId, isChecked: false, onClick: () => setSelectedClaimId(claim.claimId) }, /* @__PURE__ */ React.createElement(Group, { gap: 16, align: "center", style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        style: {
+          width: 32,
+          height: 32,
+          borderRadius: "50%",
+          background: "var(--mantine-color-neutralColor-4)",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          flexShrink: 0,
+          fontSize: 14,
+          fontWeight: 500,
+          color: "var(--mantine-color-dimmed)",
+          backgroundImage: profile?.avatarUrl ? `url(${profile.avatarUrl})` : void 0,
+          backgroundSize: "cover",
+          backgroundPosition: "center"
+        }
+      },
+      profile?.avatarUrl ? null : avatarLabel
+    ), /* @__PURE__ */ React.createElement(Stack, { gap: 0, style: { flex: 1, minWidth: 0 } }, /* @__PURE__ */ React.createElement(Text, { fw: 500, size: "md", truncate: true, style: { lineHeight: 1.5 } }, displayName), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed", truncate: true }, truncateAddress(claim.agentAddress)))), /* @__PURE__ */ React.createElement(Stack, { gap: 0, align: "flex-end", style: { flexShrink: 0, minWidth: 80 } }, /* @__PURE__ */ React.createElement(Text, { fw: 500, size: "md", c: status.color, style: { lineHeight: 1.5 } }, status.key === "approved" && /* @__PURE__ */ React.createElement(IconCheck, { size: 14, style: { verticalAlign: "middle", marginRight: 2 } }), status.label), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, getTimeAgo(claim.submissionDate || ""))));
+  })))), prefillData && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "orange", styles: actionAlertStyles }, t("actionTypes.claim.flow.amendingNotice", { defaultValue: "Amending a previously disputed claim \u2014 edit the fields below and submit to resubmit." })), /* @__PURE__ */ React.createElement(
+    BasePrimaryButton,
+    {
+      leftSection: loadingSurvey || authChecking ? /* @__PURE__ */ React.createElement(Loader, { size: 14 }) : /* @__PURE__ */ React.createElement(IconPlayerPlay, { size: 14 }),
+      onClick: startSurvey,
+      disabled: isDisabled || loadingSurvey || submitting || authChecking || !isServiceAgentAuthorized && !actAs.actAsGroup || !adminAddress
+    },
+    authChecking ? t("actionTypes.claim.flow.checkingAuthorization", { defaultValue: "Checking authorization..." }) : loadingSurvey ? t("actionTypes.shared.loadingSurvey", { defaultValue: "Loading Survey..." }) : t("actionTypes.claim.flow.startNewClaim", { defaultValue: "Start New Claim" })
+  ), !authChecking && authError && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "orange", styles: actionAlertStyles }, /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(Text, { size: "sm" }, t("actionTypes.claim.flow.authVerifyFailed", { defaultValue: "Couldn't verify your authorization \u2014 the chain RPC is unreachable." })), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, authError), /* @__PURE__ */ React.createElement(BasePrimaryButton, { size: "xs", onClick: () => setAuthRetryKey((k) => k + 1) }, t("actionTypes.claim.flow.retry", { defaultValue: "Retry" })))), !authChecking && !authError && !isServiceAgentAuthorized && !actAs.actAsGroup && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, t("actionTypes.claim.flow.errors.notAuthorized", { defaultValue: "You need service agent authorization for this collection to submit claims." })), surveyModel && !loadingSurvey && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(SurveyAiFillButton, { surveyId: openSurveyId, title: openSurveyTitle }), /* @__PURE__ */ React.createElement(StableSurvey, { model: surveyModel }))), submitting && /* @__PURE__ */ React.createElement(Group, { gap: "xs" }, /* @__PURE__ */ React.createElement(Loader, { size: "xs" }), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, t("actionTypes.claim.flow.submittingClaim", { defaultValue: "Submitting claim..." }))), error && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "red", styles: actionAlertStyles }, error));
+};
+export {
+  ClaimFlowDetail
+};
+//# sourceMappingURL=ClaimFlowDetail-UVEQMEI5.js.map