@ixo/editor 6.32.1 → 6.34.0

package/dist/CollectionLifecycleFlowDetail-WFCSVIIG.js

@@ -0,0 +1,647 @@
+import {
+  ActAsGroupSection,
+  GroupProposalStatus,
+  actAsGroupReady,
+  actAsGroupRuntimeInputs,
+  emptyActAsGroupState
+} from "./chunk-2WPEATI7.js";
+import "./chunk-TR4KO3AG.js";
+import {
+  BaseNumberInput
+} from "./chunk-76YX5R4L.js";
+import "./chunk-BZ7UPUTY.js";
+import {
+  BaseSelect
+} from "./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 {
+  BaseTextInput
+} from "./chunk-WO7V6ZNC.js";
+import "./chunk-4DGCCXD6.js";
+import "./chunk-7W7UUUIE.js";
+import "./chunk-TS2LNBF2.js";
+
+// src/mantine/blocks/action/actionTypes/collection/CollectionLifecycleFlowDetail.tsx
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Badge, Box, Button, Group, Loader, Overlay, SegmentedControl, Stack, Text } from "@mantine/core";
+import { DateTimePicker } from "@mantine/dates";
+import { IconAlertCircle, IconCheck, IconRefresh } from "@tabler/icons-react";
+
+// src/core/lib/actionRegistry/actions/collection/failure.ts
+var ACTION_INPUT_REQUIRED_ERROR_CODE = "ACTION_INPUT_REQUIRED";
+var COLLECTION_MANAGE_OPERATIONS = /* @__PURE__ */ new Set(["refresh", "updateState", "updateDates", "updateQuota", "updatePayments", "updateIntents"]);
+function collectionLifecycleRuntimeError(error, runtimeInputs, at = Date.now()) {
+  const message = error instanceof Error ? error.message : String(error || "Collection lifecycle action failed");
+  const operation = runtimeInputs.operation;
+  const collectionId = String(runtimeInputs.collectionId || "").trim();
+  const isMissingCollectionId = operation !== "create" && COLLECTION_MANAGE_OPERATIONS.has(operation) && collectionId.length === 0 && message.includes("collectionId is required");
+  if (!isMissingCollectionId) return { message, at };
+  return {
+    message,
+    code: ACTION_INPUT_REQUIRED_ERROR_CODE,
+    at,
+    data: {
+      actionType: "qi/collection.lifecycle",
+      field: "collectionId",
+      operation
+    }
+  };
+}
+
+// src/mantine/blocks/action/actionTypes/collection/CollectionLifecycleFlowDetail.tsx
+var LOG = "[collection.lifecycle]";
+function parseTemplateInputs(json) {
+  try {
+    const parsed = typeof json === "string" ? json ? JSON.parse(json) : {} : json || {};
+    return {
+      entity: parsed?.entity || "",
+      protocol: parsed?.protocol || "",
+      collectionId: parsed?.collectionId || "",
+      quota: parsed?.quota != null ? String(parsed.quota) : "",
+      startDate: parsed?.startDate || "",
+      endDate: parsed?.endDate || "",
+      payments: parsed?.payments,
+      intents: parsed?.intents,
+      state: typeof parsed?.state === "number" ? parsed.state : void 0
+    };
+  } catch {
+    return { entity: "", protocol: "", collectionId: "", quota: "", startDate: "", endDate: "" };
+  }
+}
+var STATE_LABELS = {
+  [0 /* OPEN */]: "Open",
+  [1 /* PAUSED */]: "Paused",
+  [2 /* CLOSED */]: "Closed"
+};
+function stateLabel(state) {
+  if (state == null) return "Unknown";
+  return STATE_LABELS[state] ?? `State ${state}`;
+}
+function formatQuota(quota) {
+  if (quota == null || quota === "") return "\u2014";
+  if (quota === "0") return "Unlimited";
+  return quota;
+}
+function toNumberOrUndefined(value) {
+  if (value === "" || value == null) return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+function isoToDate(iso) {
+  if (!iso) return null;
+  const d = new Date(iso);
+  return isNaN(d.getTime()) ? null : d;
+}
+function dateToIso(value) {
+  if (!value) return "";
+  try {
+    return value.toISOString();
+  } catch {
+    return "";
+  }
+}
+var PAYMENT_TOKENS = ["IXO", "USDC"];
+var USDC_IBC_DENOM = "ibc/6BBE9BD4246F8E04948D5A4EEE7164B2630263B9EBB5E7DC5F0A46C62A2FF97B";
+var MICRO = 1e6;
+var PAYMENT_LEGS = [
+  { key: "submission", label: "Submission", description: "Paid when a claim is submitted." },
+  { key: "evaluation", label: "Evaluation", description: "Paid to the evaluator per claim." },
+  { key: "approval", label: "Approval", description: "Paid when a claim is approved." },
+  { key: "rejection", label: "Rejection", description: "Paid when a claim is rejected." }
+];
+function emptyPaymentsInput() {
+  return {
+    submission: { token: "IXO", amount: "" },
+    evaluation: { token: "IXO", amount: "" },
+    approval: { token: "IXO", amount: "" },
+    rejection: { token: "IXO", amount: "" }
+  };
+}
+function legToInput(leg) {
+  const coin = leg?.amount?.[0];
+  if (!coin || !coin.amount || coin.amount === "0") return { token: "IXO", amount: "" };
+  let token = "IXO";
+  let isMicro = false;
+  if (coin.denom === "uixo") {
+    token = "IXO";
+    isMicro = true;
+  } else if (coin.denom === USDC_IBC_DENOM || coin.denom.startsWith("ibc/")) {
+    token = "USDC";
+    isMicro = true;
+  } else if (coin.denom === "USDC") {
+    token = "USDC";
+  } else if (coin.denom === "IXO") {
+    token = "IXO";
+  }
+  const raw = Number(coin.amount);
+  if (!Number.isFinite(raw)) return { token, amount: "" };
+  const display = isMicro ? raw / MICRO : raw;
+  return { token, amount: String(display) };
+}
+function paymentsToInput(payments) {
+  if (!payments) return emptyPaymentsInput();
+  return {
+    submission: legToInput(payments.submission),
+    evaluation: legToInput(payments.evaluation),
+    approval: legToInput(payments.approval),
+    rejection: legToInput(payments.rejection)
+  };
+}
+function inputToLeg(leg) {
+  const n = toNumberOrUndefined(leg.amount);
+  if (n == null || n <= 0) return void 0;
+  return { account: "", amount: [{ denom: leg.token, amount: leg.amount }] };
+}
+function inputToPayments(input) {
+  const payments = {
+    submission: inputToLeg(input.submission),
+    evaluation: inputToLeg(input.evaluation),
+    approval: inputToLeg(input.approval),
+    rejection: inputToLeg(input.rejection)
+  };
+  if (!payments.submission && !payments.evaluation && !payments.approval && !payments.rejection) {
+    return void 0;
+  }
+  return payments;
+}
+var CollectionLifecycleFlowDetail = ({
+  inputs,
+  editor,
+  block,
+  runtime,
+  updateRuntime,
+  isDisabled,
+  provideSigningHandler,
+  unlockSigning,
+  registerRuntimeInputs,
+  executeAction
+}) => {
+  const [actAs, setActAs] = useState(emptyActAsGroupState());
+  const parsed = useMemo(() => parseTemplateInputs(inputs), [inputs]);
+  const editorDocument = editor?.document || [];
+  const runtimeReader = useRunRuntimeReader(editor);
+  const resolveOpts = useMemo(() => ({ yRuntime: runtimeReader }), [runtimeReader]);
+  const boundCollectionId = useMemo(() => resolveReferences(parsed.collectionId || "", editorDocument, resolveOpts).trim(), [parsed.collectionId, editorDocument, resolveOpts]);
+  const output = runtime.output || void 0;
+  const outputCollectionId = output?.collectionId || "";
+  const effectiveCollectionId = outputCollectionId || boundCollectionId;
+  const isRunning = runtime.state === "running";
+  const isFailed = runtime.state === "failed";
+  const errorMessage = runtime.error?.message || null;
+  const isCompletedWithProof = runtime.state === "completed" && !!outputCollectionId;
+  const isStale = runtime.state === "completed" && !outputCollectionId;
+  const hasSnapshot = !!outputCollectionId;
+  const isManageMode = !!boundCollectionId || hasSnapshot;
+  const isCreateMode = !isManageMode;
+  const [operation, setOperation] = useState(isCreateMode ? "create" : "updateState");
+  useEffect(() => {
+    if (hasSnapshot && operation === "create") {
+      setOperation("updateState");
+    }
+  }, [hasSnapshot, operation]);
+  const [createQuota, setCreateQuota] = useState(parsed.quota || "0");
+  const [createStartDate, setCreateStartDate] = useState(parsed.startDate || "");
+  const [createEndDate, setCreateEndDate] = useState(parsed.endDate || "");
+  const [createPayments, setCreatePayments] = useState(() => paymentsToInput(parsed.payments));
+  const [targetState, setTargetState] = useState(output?.state ?? 0 /* OPEN */);
+  const [editStartDate, setEditStartDate] = useState("");
+  const [editEndDate, setEditEndDate] = useState("");
+  const [editQuota, setEditQuota] = useState("");
+  const [editPayments, setEditPayments] = useState(() => paymentsToInput(output?.payments));
+  const [editIntentsJson, setEditIntentsJson] = useState("");
+  const seededFromRef = useRef("");
+  useEffect(() => {
+    if (!hasSnapshot) return;
+    const snapshotKey = JSON.stringify({
+      id: outputCollectionId,
+      s: output?.state,
+      sd: output?.startDate,
+      ed: output?.endDate,
+      q: output?.quota,
+      executedAt: runtime.executedAt
+    });
+    if (seededFromRef.current === snapshotKey) return;
+    seededFromRef.current = snapshotKey;
+    setTargetState(output?.state ?? 0 /* OPEN */);
+    setEditStartDate(output?.startDate || "");
+    setEditEndDate(output?.endDate || "");
+    setEditQuota(output?.quota != null ? String(output.quota) : "");
+    setEditPayments(paymentsToInput(output?.payments));
+    setEditIntentsJson(output?.intents ? JSON.stringify(output.intents, null, 2) : "");
+  }, [hasSnapshot, outputCollectionId, output?.state, output?.startDate, output?.endDate, output?.quota, output?.payments, output?.intents, runtime.executedAt]);
+  const refreshOnLoadRef = useRef(false);
+  const runRefresh = useCallback(async () => {
+    if (!executeAction) {
+      updateRuntime({ state: "failed", error: { message: "Shared action executor is unavailable", at: Date.now() } });
+      return;
+    }
+    const collectionId = effectiveCollectionId;
+    if (!collectionId) return;
+    console.log(`${LOG} refresh \u2192`, { collectionId });
+    try {
+      const outcome = await executeAction({ runtimeInputs: { operation: "refresh", collectionId } });
+      if (!outcome.success) {
+        throw new Error(outcome.error || "Failed to refresh collection state");
+      }
+      const payload = outcome.output;
+      if (!payload?.collectionId) {
+        throw new Error("Refresh returned no collection state. Check the [collection:get] handler logs.");
+      }
+      console.log(`${LOG} refresh success`, { collectionId: payload.collectionId });
+    } catch (err) {
+      const failure = collectionLifecycleRuntimeError(err, { operation: "refresh", collectionId });
+      const message = failure.message;
+      console.error(`${LOG} refresh failed`, { message });
+      updateRuntime({ state: "failed", error: failure });
+    }
+  }, [executeAction, effectiveCollectionId, updateRuntime]);
+  useEffect(() => {
+    if (refreshOnLoadRef.current) return;
+    if (!boundCollectionId) return;
+    if (hasSnapshot) return;
+    if (isRunning || isFailed) return;
+    if (runtime.state === "needs_verification") return;
+    refreshOnLoadRef.current = true;
+    console.log(`${LOG} refresh-on-load`, { boundCollectionId });
+    runRefresh();
+  }, [boundCollectionId, hasSnapshot, isRunning, isFailed, runtime.state, runRefresh]);
+  const persistedIdRef = useRef(false);
+  useEffect(() => {
+    if (boundCollectionId) return;
+    if (!outputCollectionId) return;
+    if (!editor || !block) return;
+    if (persistedIdRef.current) return;
+    if (parsed.collectionId === outputCollectionId) return;
+    persistedIdRef.current = true;
+    try {
+      const raw = inputs ? JSON.parse(inputs) : {};
+      raw.collectionId = outputCollectionId;
+      editor.updateBlock(block, { props: { ...block.props, inputs: JSON.stringify(raw) } });
+      console.log(`${LOG} persisted collectionId to block inputs`, { collectionId: outputCollectionId });
+    } catch (err) {
+      persistedIdRef.current = false;
+      console.warn(`${LOG} failed to persist collectionId to block inputs`, err);
+    }
+  }, [boundCollectionId, outputCollectionId, parsed.collectionId, inputs, editor, block]);
+  const currentCount = toNumberOrUndefined(output?.count) ?? 0;
+  const validation = useMemo(() => {
+    if (operation === "refresh") return { ok: true };
+    if (operation === "create") {
+      if (!parsed.entity) return { ok: false, error: "Entity (deed) DID is required \u2014 configure it in template mode." };
+      if (!parsed.protocol) return { ok: false, error: "Protocol is required \u2014 configure it in template mode." };
+      const q = toNumberOrUndefined(createQuota);
+      if (q == null || q < 0) return { ok: false, error: "Quota must be 0 (unlimited) or a positive number." };
+      if (createStartDate && createEndDate && new Date(createEndDate) <= new Date(createStartDate)) {
+        return { ok: false, error: "End date must be after the start date." };
+      }
+      return { ok: true };
+    }
+    if (!effectiveCollectionId) return { ok: false, error: "No collection loaded yet." };
+    if (operation === "updateState") {
+      if (output?.state != null && output.state === targetState) return { ok: false, error: "Collection is already in that state." };
+      return { ok: true };
+    }
+    if (operation === "updateDates") {
+      if (!editStartDate && !editEndDate) return { ok: false, error: "Set at least one of start / end date." };
+      if (editStartDate && editEndDate && new Date(editEndDate) <= new Date(editStartDate)) {
+        return { ok: false, error: "End date must be after the start date." };
+      }
+      return { ok: true };
+    }
+    if (operation === "updateQuota") {
+      const q = toNumberOrUndefined(editQuota);
+      if (q == null || q < 0) return { ok: false, error: "Quota must be 0 (unlimited) or a positive number." };
+      if (q !== 0 && q < currentCount) {
+        return { ok: false, error: `Quota cannot be below the submitted count (${currentCount}). Use 0 for unlimited.` };
+      }
+      return { ok: true };
+    }
+    if (operation === "updatePayments") {
+      if (!inputToPayments(editPayments)) {
+        return { ok: false, error: "Set a payout amount for at least one claim stage." };
+      }
+      return { ok: true };
+    }
+    if (operation === "updateIntents") {
+      if (!editIntentsJson.trim()) return { ok: false, error: "Intents configuration is required." };
+      try {
+        JSON.parse(editIntentsJson);
+      } catch {
+        return { ok: false, error: "Intents must be valid JSON." };
+      }
+      return { ok: true };
+    }
+    return { ok: false, error: "Unsupported operation." };
+  }, [
+    operation,
+    parsed.entity,
+    parsed.protocol,
+    createQuota,
+    createStartDate,
+    createEndDate,
+    effectiveCollectionId,
+    output?.state,
+    targetState,
+    editStartDate,
+    editEndDate,
+    editQuota,
+    currentCount,
+    editPayments,
+    editIntentsJson
+  ]);
+  const buildRuntimeInputs = useCallback(() => {
+    const targetId = effectiveCollectionId || void 0;
+    switch (operation) {
+      case "create":
+        return {
+          operation: "create",
+          quota: String(toNumberOrUndefined(createQuota) ?? 0),
+          startDate: createStartDate || void 0,
+          endDate: createEndDate || void 0,
+          payments: inputToPayments(createPayments),
+          intents: parsed.intents,
+          state: parsed.state
+        };
+      case "updateState":
+        return { operation: "updateState", collectionId: targetId, state: targetState };
+      case "updateDates":
+        return { operation: "updateDates", collectionId: targetId, startDate: editStartDate || void 0, endDate: editEndDate || void 0 };
+      case "updateQuota":
+        return { operation: "updateQuota", collectionId: targetId, quota: String(toNumberOrUndefined(editQuota) ?? 0) };
+      case "updatePayments":
+        return { operation: "updatePayments", collectionId: targetId, payments: inputToPayments(editPayments) };
+      case "updateIntents":
+        return { operation: "updateIntents", collectionId: targetId, intents: JSON.parse(editIntentsJson) };
+      case "refresh":
+      default:
+        return { operation: "refresh", collectionId: targetId };
+    }
+  }, [
+    operation,
+    effectiveCollectionId,
+    createQuota,
+    createStartDate,
+    createEndDate,
+    createPayments,
+    parsed.intents,
+    parsed.state,
+    targetState,
+    editStartDate,
+    editEndDate,
+    editQuota,
+    editPayments,
+    editIntentsJson
+  ]);
+  useEffect(() => {
+    if (!registerRuntimeInputs) return;
+    try {
+      registerRuntimeInputs(buildRuntimeInputs());
+    } catch {
+      registerRuntimeInputs({ operation });
+    }
+  }, [registerRuntimeInputs, buildRuntimeInputs, operation]);
+  useEffect(() => {
+    unlockSigning?.(!isDisabled && !isRunning && validation.ok && actAsGroupReady(actAs));
+  }, [unlockSigning, isDisabled, isRunning, validation.ok]);
+  const execute = useCallback(async () => {
+    if (isDisabled || isRunning) return;
+    if (!executeAction) {
+      updateRuntime({ state: "failed", error: { message: "Shared action executor is unavailable", at: Date.now() } });
+      return;
+    }
+    if (!validation.ok) {
+      console.warn(`${LOG} refusing to execute \u2014 invalid inputs`, { operation, error: validation.error });
+      return;
+    }
+    let runtimeInputs;
+    try {
+      runtimeInputs = buildRuntimeInputs();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Invalid operation inputs";
+      updateRuntime({ state: "failed", error: { message, at: Date.now() } });
+      return;
+    }
+    console.log(`${LOG} execute \u2192`, { operation: runtimeInputs.operation, collectionId: effectiveCollectionId });
+    try {
+      const outcome = await executeAction({ runtimeInputs: { ...runtimeInputs, ...actAsGroupRuntimeInputs(actAs) } });
+      if (!outcome.success) {
+        throw new Error(outcome.error || `Collection ${runtimeInputs.operation} failed`);
+      }
+      const payload = outcome.output;
+      if (!payload?.collectionId) {
+        throw new Error("Action returned success without a collection state. Check the [collection] handler logs.");
+      }
+      console.log(`${LOG} execute success`, { operation: runtimeInputs.operation, collectionId: payload.collectionId, state: payload.state });
+    } catch (err) {
+      const failure = collectionLifecycleRuntimeError(err, runtimeInputs);
+      const message = failure.message;
+      console.error(`${LOG} execute failed`, { operation: runtimeInputs.operation, message });
+      updateRuntime({ state: "failed", error: failure });
+    }
+  }, [isDisabled, isRunning, executeAction, validation.ok, validation.error, operation, buildRuntimeInputs, effectiveCollectionId, updateRuntime]);
+  useEffect(() => {
+    if (!provideSigningHandler) return;
+    provideSigningHandler(execute);
+  }, [provideSigningHandler, execute]);
+  const handleReset = useCallback(() => {
+    console.log(`${LOG} reset \u2192 idle`);
+    refreshOnLoadRef.current = false;
+    seededFromRef.current = "";
+    updateRuntime({ state: "idle", error: void 0, output: {} });
+  }, [updateRuntime]);
+  const handleForceRun = useCallback(() => {
+    console.log(`${LOG} force run`);
+    updateRuntime({ state: "idle", error: void 0, output: {} });
+    setTimeout(() => {
+      execute();
+    }, 0);
+  }, [updateRuntime, execute]);
+  const handleManualRefresh = useCallback(() => {
+    refreshOnLoadRef.current = false;
+    runRefresh();
+  }, [runRefresh]);
+  const title = block?.props?.title || (isCreateMode ? "Create Claim Collection" : "Manage Claim Collection");
+  const description = block?.props?.description || "";
+  return /* @__PURE__ */ React.createElement(Stack, { gap: "md", pos: "relative" }, /* @__PURE__ */ React.createElement(GroupProposalStatus, { editor, block, runtime }), runtime?.state !== "awaiting_readback" && /* @__PURE__ */ React.createElement(ActAsGroupSection, { value: actAs, onChange: setActAs, isDisabled, actionLabel: "update this collection" }), /* @__PURE__ */ React.createElement(Stack, { gap: 2 }, /* @__PURE__ */ React.createElement(Text, { fw: 600 }, title), description && /* @__PURE__ */ React.createElement(Text, { size: "sm", c: "dimmed" }, description)), isStale && /* @__PURE__ */ React.createElement(DismissibleAlert, { icon: /* @__PURE__ */ React.createElement(IconAlertCircle, { size: 16 }), color: "yellow", title: "Inconsistent State" }, /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(Text, { size: "sm" }, "Block was marked completed but no collection state was recorded. This is stale state from a previous run \u2014 reset and re-run."), /* @__PURE__ */ React.createElement(Group, null, /* @__PURE__ */ React.createElement(Button, { variant: "outline", size: "xs", onClick: handleReset }, "Reset"), /* @__PURE__ */ React.createElement(Button, { variant: "filled", size: "xs", onClick: handleForceRun, disabled: !validation.ok }, "Force Run Now")))), isFailed && /* @__PURE__ */ React.createElement(DismissibleAlert, { icon: /* @__PURE__ */ React.createElement(IconAlertCircle, { size: 16 }), color: "red", title: "Action Failed", styles: actionAlertStyles }, /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, errorMessage && /* @__PURE__ */ React.createElement(Text, { size: "sm" }, errorMessage), /* @__PURE__ */ React.createElement(Group, null, /* @__PURE__ */ React.createElement(Button, { variant: "outline", size: "xs", onClick: handleReset }, "Reset"), !!effectiveCollectionId && /* @__PURE__ */ React.createElement(Button, { variant: "filled", size: "xs", leftSection: /* @__PURE__ */ React.createElement(IconRefresh, { size: 14 }), onClick: handleManualRefresh }, "Refresh State")))), isManageMode && !hasSnapshot && !isRunning && !isFailed && /* @__PURE__ */ React.createElement(Group, { gap: "xs" }, /* @__PURE__ */ React.createElement(Loader, { size: 14 }), /* @__PURE__ */ React.createElement(Text, { size: "sm", c: "dimmed" }, "Loading collection ", effectiveCollectionId ? `(${effectiveCollectionId})` : "", "\u2026")), hasSnapshot && /* @__PURE__ */ React.createElement(Stack, { gap: "md" }, /* @__PURE__ */ React.createElement(StatsStrip, { output }), isCompletedWithProof && /* @__PURE__ */ React.createElement(DismissibleAlert, { icon: /* @__PURE__ */ React.createElement(IconCheck, { size: 16 }), color: "green", styles: actionAlertStyles }, "Collection ", outputCollectionId, " synced \u2014 ", stateLabel(output?.state), "."), /* @__PURE__ */ React.createElement(
+    SegmentedControl,
+    {
+      fullWidth: true,
+      value: operation === "create" ? "updateState" : operation,
+      onChange: (value) => setOperation(value),
+      disabled: isDisabled || isRunning,
+      data: [
+        { label: "State", value: "updateState" },
+        { label: "Dates", value: "updateDates" },
+        { label: "Quota", value: "updateQuota" },
+        { label: "Payments", value: "updatePayments" },
+        { label: "Intents", value: "updateIntents" }
+      ]
+    }
+  ), operation === "updateState" && /* @__PURE__ */ React.createElement(
+    SegmentedControl,
+    {
+      fullWidth: true,
+      value: String(targetState),
+      onChange: (value) => setTargetState(Number(value)),
+      disabled: isDisabled || isRunning,
+      data: [
+        { label: "Open", value: String(0 /* OPEN */) },
+        { label: "Paused", value: String(1 /* PAUSED */) },
+        { label: "Closed", value: String(2 /* CLOSED */) }
+      ]
+    }
+  ), operation === "updateDates" && /* @__PURE__ */ React.createElement(Group, { grow: true, align: "flex-start" }, /* @__PURE__ */ React.createElement(
+    DateTimePicker,
+    {
+      label: "Start date",
+      placeholder: "Select start date and time",
+      valueFormat: "DD MMM YYYY, HH:mm",
+      clearable: true,
+      value: isoToDate(editStartDate),
+      onChange: (date) => setEditStartDate(dateToIso(date)),
+      disabled: isDisabled || isRunning
+    }
+  ), /* @__PURE__ */ React.createElement(
+    DateTimePicker,
+    {
+      label: "End date",
+      placeholder: "Select end date and time",
+      valueFormat: "DD MMM YYYY, HH:mm",
+      clearable: true,
+      minDate: isoToDate(editStartDate) || void 0,
+      value: isoToDate(editEndDate),
+      onChange: (date) => setEditEndDate(dateToIso(date)),
+      disabled: isDisabled || isRunning
+    }
+  )), operation === "updateQuota" && /* @__PURE__ */ React.createElement(
+    BaseNumberInput,
+    {
+      label: "Quota (0 = unlimited)",
+      description: `Submitted count: ${currentCount}. Quota must be 0 or at least ${currentCount}.`,
+      min: 0,
+      value: editQuota === "" ? "" : Number(editQuota),
+      onChange: (value) => setEditQuota(value === "" || value == null ? "" : String(value)),
+      disabled: isDisabled || isRunning
+    }
+  ), operation === "updatePayments" && /* @__PURE__ */ React.createElement(PaymentsEditor, { value: editPayments, onChange: setEditPayments, disabled: isDisabled || isRunning }), operation === "updateIntents" && /* @__PURE__ */ React.createElement(
+    BaseTextInput,
+    {
+      label: "Intents (JSON)",
+      placeholder: '{"allowed":true}',
+      value: editIntentsJson,
+      onChange: (e) => setEditIntentsJson(e.currentTarget.value),
+      disabled: isDisabled || isRunning
+    }
+  ), !validation.ok && validation.error && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, validation.error)), isCreateMode && !hasSnapshot && /* @__PURE__ */ React.createElement(Stack, { gap: "md" }, (!parsed.entity || !parsed.protocol) && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, "Configure the entity DID and protocol in template mode before creating a collection."), /* @__PURE__ */ React.createElement(
+    BaseNumberInput,
+    {
+      label: "Quota (0 = unlimited)",
+      min: 0,
+      value: createQuota === "" ? "" : Number(createQuota),
+      onChange: (value) => setCreateQuota(value === "" || value == null ? "" : String(value)),
+      disabled: isDisabled || isRunning
+    }
+  ), /* @__PURE__ */ React.createElement(Group, { grow: true, align: "flex-start" }, /* @__PURE__ */ React.createElement(
+    DateTimePicker,
+    {
+      label: "Start date",
+      placeholder: "Select start date and time",
+      valueFormat: "DD MMM YYYY, HH:mm",
+      clearable: true,
+      value: isoToDate(createStartDate),
+      onChange: (date) => setCreateStartDate(dateToIso(date)),
+      disabled: isDisabled || isRunning
+    }
+  ), /* @__PURE__ */ React.createElement(
+    DateTimePicker,
+    {
+      label: "End date",
+      placeholder: "Select end date and time",
+      valueFormat: "DD MMM YYYY, HH:mm",
+      clearable: true,
+      minDate: isoToDate(createStartDate) || void 0,
+      value: isoToDate(createEndDate),
+      onChange: (date) => setCreateEndDate(dateToIso(date)),
+      disabled: isDisabled || isRunning
+    }
+  )), /* @__PURE__ */ React.createElement(PaymentsEditor, { value: createPayments, onChange: setCreatePayments, disabled: isDisabled || isRunning }), !validation.ok && validation.error && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, validation.error)), isDisabled && /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, "This block is currently disabled."), isRunning && /* @__PURE__ */ React.createElement(Overlay, { color: "var(--mantine-color-body)", backgroundOpacity: 0.6, blur: 1, zIndex: 5, radius: "md" }, /* @__PURE__ */ React.createElement(Group, { gap: "xs", justify: "center", h: "100%" }, /* @__PURE__ */ React.createElement(Loader, { size: 16 }), /* @__PURE__ */ React.createElement(Text, { size: "sm" }, "Syncing collection state\u2026"))));
+};
+var PaymentsEditor = ({ value, onChange, disabled }) => {
+  const setLeg = (key, patch) => {
+    onChange({ ...value, [key]: { ...value[key], ...patch } });
+  };
+  return /* @__PURE__ */ React.createElement(Stack, { gap: "sm" }, /* @__PURE__ */ React.createElement(Stack, { gap: 2 }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 500 }, "Payouts"), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, "Optional payout per claim stage, paid from the entity admin account. Leave blank for no payout.")), PAYMENT_LEGS.map(({ key, label, description }) => /* @__PURE__ */ React.createElement(Group, { key, align: "flex-end", gap: "sm", wrap: "nowrap" }, /* @__PURE__ */ React.createElement(
+    BaseNumberInput,
+    {
+      label,
+      description,
+      placeholder: "0",
+      min: 0,
+      decimalScale: 6,
+      style: { flex: 1 },
+      value: value[key].amount === "" ? "" : Number(value[key].amount),
+      onChange: (v) => setLeg(key, { amount: v === "" || v == null ? "" : String(v) }),
+      disabled
+    }
+  ), /* @__PURE__ */ React.createElement(
+    BaseSelect,
+    {
+      label: "Token",
+      w: 110,
+      allowDeselect: false,
+      data: PAYMENT_TOKENS.map((t) => ({ value: t, label: t })),
+      value: value[key].token,
+      onChange: (v) => setLeg(key, { token: v || "IXO" }),
+      disabled
+    }
+  ))));
+};
+var StatsStrip = ({ output }) => {
+  return /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      style: {
+        border: "1px solid var(--mantine-color-neutralColor-6)",
+        borderRadius: 8,
+        padding: 12,
+        background: "var(--mantine-color-neutralColor-5)"
+      }
+    },
+    /* @__PURE__ */ React.createElement(Group, { justify: "space-between", wrap: "wrap", gap: "md" }, /* @__PURE__ */ React.createElement(Stat, { label: "Collection", value: output.collectionId, mono: true }), /* @__PURE__ */ React.createElement(Stat, { label: "State", value: stateLabel(output.state), badge: true, stateValue: output.state }), /* @__PURE__ */ React.createElement(Stat, { label: "Count", value: String(output.count ?? "0") }), /* @__PURE__ */ React.createElement(Stat, { label: "Quota", value: formatQuota(output.quota) }), output.startDate && /* @__PURE__ */ React.createElement(Stat, { label: "Start", value: output.startDate }), output.endDate && /* @__PURE__ */ React.createElement(Stat, { label: "End", value: output.endDate }))
+  );
+};
+var Stat = ({ label, value, mono, badge, stateValue }) => {
+  const badgeColor = stateValue === 0 /* OPEN */ ? "green" : stateValue === 1 /* PAUSED */ ? "yellow" : "red";
+  return /* @__PURE__ */ React.createElement(Stack, { gap: 2, style: { minWidth: 0 } }, /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, label), badge ? /* @__PURE__ */ React.createElement(Badge, { color: badgeColor, variant: "light" }, value) : /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600, style: mono ? { wordBreak: "break-all", fontFamily: "var(--mantine-font-family-monospace)" } : void 0 }, value));
+};
+var CollectionLifecycleFlowDetail_default = CollectionLifecycleFlowDetail;
+export {
+  CollectionLifecycleFlowDetail,
+  CollectionLifecycleFlowDetail_default as default
+};
+//# sourceMappingURL=CollectionLifecycleFlowDetail-WFCSVIIG.js.map