@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-JBBFSORW.js

@@ -0,0 +1,846 @@
+import {
+  resolveClaimFileRef
+} from "./chunk-OMLI45ER.js";
+import {
+  UTF8_BOM,
+  rowsToCsv,
+  timestampSuffix
+} from "./chunk-5NTKDOP6.js";
+import {
+  getClaimStatusInfo
+} from "./chunk-NKE4TL43.js";
+import {
+  icon
+} from "./chunk-YN4CEKCF.js";
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/DownloadCsvButton.tsx
+import React, { useCallback, useState } from "react";
+import { ActionIcon } from "@mantine/core";
+import { IconDownload, IconFileZip } from "@tabler/icons-react";
+var DownloadIconButton = ({ onDownload, disabled, label, Icon, onError }) => {
+  const [busy, setBusy] = useState(false);
+  const handleClick = useCallback(async () => {
+    setBusy(true);
+    try {
+      await onDownload();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "The download failed.";
+      console.error(`[dataExport] ${label} failed`, err);
+      onError?.(message);
+    } finally {
+      setBusy(false);
+    }
+  }, [onDownload, onError, label]);
+  return /* @__PURE__ */ React.createElement(ActionIcon, { variant: "subtle", color: "gray", size: "sm", "aria-label": label, title: label, loading: busy, disabled, onClick: handleClick }, /* @__PURE__ */ React.createElement(Icon, { size: 16 }));
+};
+var DownloadCsvButton = ({ onDownload, disabled, label = "Download CSV", onError }) => /* @__PURE__ */ React.createElement(DownloadIconButton, { onDownload, disabled, label, Icon: IconDownload, onError });
+var DownloadZipButton = ({ onDownload, disabled, label = "Download CSV + media (ZIP)", onError }) => /* @__PURE__ */ React.createElement(DownloadIconButton, { onDownload, disabled, label, Icon: IconFileZip, onError });
+
+// src/mantine/utils/bidStatus.ts
+var STATUS_META = {
+  approved: { label: "Approved", color: "green", isTerminal: true },
+  rejected: { label: "Rejected", color: "red", isTerminal: true },
+  pending: { label: "Pending", color: "yellow", isTerminal: false }
+};
+function parseStatusKey(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "approved" || normalized === "approve") return "approved";
+  if (normalized === "rejected" || normalized === "reject") return "rejected";
+  if (normalized === "pending") return "pending";
+  return null;
+}
+function granteeRoleForBid(bid) {
+  const role = String(bid?.role || "").toLowerCase();
+  return role === "evaluation_agent" || role === "ea" ? "evaluate" : "submit";
+}
+function getBidStatusInfo(bid, context = {}) {
+  const asInfo = (key, source) => ({ key, ...STATUS_META[key], source });
+  const session = context.evaluatedByBidId?.[bid?.id ?? ""];
+  if (session) return asInfo(session, "session");
+  const direct = parseStatusKey(bid?.status);
+  if (direct) return asInfo(direct, "payload");
+  try {
+    const data = typeof bid?.data === "string" ? JSON.parse(bid.data) : bid?.data;
+    const embedded = parseStatusKey(data?.status);
+    if (embedded) return asInfo(embedded, "payload");
+  } catch {
+  }
+  const grantees = context.grantees;
+  if (grantees?.length) {
+    const wanted = granteeRoleForBid(bid);
+    if (grantees.some((grantee) => grantee.address === bid?.address && grantee.role === wanted)) {
+      return asInfo("approved", "grant");
+    }
+  }
+  return asInfo("pending", "default");
+}
+function describeGrantState(address, grantees) {
+  const grants = grantees.filter((grantee) => grantee.address === address);
+  if (grants.length === 0) return "none";
+  return grants.map((grant) => `${grant.role} (quota ${grant.agentQuota ?? "\u2014"})`).join("; ");
+}
+var BID_GRANT_STATE_LABELS = {
+  open: "Open \u2014 awaiting decision",
+  granted: "Granted \u2014 active",
+  granted_other_role: "Granted \u2014 different role",
+  lapsed: "No active grant"
+};
+function classifyBidGrantState(bid, grantees, context = {}) {
+  const decided = getBidStatusInfo(bid, { ...context, grantees: void 0 }).key !== "pending" || !!bid.decided;
+  if (!decided) return "open";
+  const wanted = granteeRoleForBid(bid);
+  const onCollection = grantees.filter((grantee) => grantee.address === bid.address);
+  if (onCollection.some((grantee) => grantee.role === wanted)) return "granted";
+  if (onCollection.length > 0) return "granted_other_role";
+  return "lapsed";
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/buildBidRows.ts
+function bidAnswers(bid) {
+  try {
+    const parsed = typeof bid.data === "string" ? JSON.parse(bid.data) : bid.data;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    return { data: bid.data };
+  }
+  return {};
+}
+function buildBidRows(bids, grantees, options = {}) {
+  const statusContext = { grantees, evaluatedByBidId: options.evaluatedByBidId };
+  return bids.map((bid) => {
+    const answers = options.answersByBidId?.[bid.id] ?? bidAnswers(bid);
+    const status = getBidStatusInfo(bid, statusContext);
+    const grantState = classifyBidGrantState(bid, grantees, statusContext);
+    return {
+      bidId: bid.id,
+      name: options.namesByDid?.[bid.did] || "",
+      did: bid.did,
+      address: bid.address,
+      role: bid.role,
+      created: bid.created,
+      status: status.key,
+      statusSource: status.source,
+      // The column that answers "did anything come of this bid?". `lapsed`
+      // means the account submitted, was decided, and holds no grant today —
+      // a population that appears in neither the bids list nor the grant list.
+      bidState: grantState,
+      bidStateNote: BID_GRANT_STATE_LABELS[grantState],
+      activeGrant: grantState === "granted" || grantState === "granted_other_role" ? "yes" : "no",
+      grantDetail: describeGrantState(bid.address, grantees),
+      ...answers
+    };
+  });
+}
+
+// src/core/utils/zip.ts
+var MAX_ENTRIES = 65535;
+var MAX_ARCHIVE_BYTES = 4294967295;
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i += 1) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function dosDateTime(date) {
+  const year = Math.max(1980, date.getFullYear());
+  return {
+    time: (date.getHours() & 31) << 11 | (date.getMinutes() & 63) << 5 | date.getSeconds() >> 1 & 31,
+    date: (year - 1980 & 127) << 9 | (date.getMonth() + 1 & 15) << 5 | date.getDate() & 31
+  };
+}
+function toBytes(data, encoder) {
+  return typeof data === "string" ? encoder.encode(data) : data;
+}
+function createZipBlob(entries, options) {
+  if (entries.length > MAX_ENTRIES) {
+    throw new Error(`ZIP archives are limited to ${MAX_ENTRIES} entries (got ${entries.length}).`);
+  }
+  const encoder = new TextEncoder();
+  const { time, date } = dosDateTime(options?.modifiedAt ?? /* @__PURE__ */ new Date());
+  const seen = /* @__PURE__ */ new Set();
+  const prepared = entries.map((entry) => {
+    const path = entry.path.replace(/^\/+/, "");
+    if (seen.has(path)) throw new Error(`Duplicate ZIP entry path: ${path}`);
+    seen.add(path);
+    const nameBytes = encoder.encode(path);
+    const dataBytes = toBytes(entry.data, encoder);
+    return { nameBytes, dataBytes, crc: crc32(dataBytes), offset: 0 };
+  });
+  const localSize = prepared.reduce((sum, e) => sum + 30 + e.nameBytes.length + e.dataBytes.length, 0);
+  const centralSize = prepared.reduce((sum, e) => sum + 46 + e.nameBytes.length, 0);
+  const total = localSize + centralSize + 22;
+  if (total > MAX_ARCHIVE_BYTES) {
+    throw new Error(`Archive would be ${Math.round(total / 1024 / 1024)} MB, over the 4 GB ZIP limit. Export a smaller selection.`);
+  }
+  const buffer = new Uint8Array(total);
+  const view = new DataView(buffer.buffer);
+  let cursor = 0;
+  const u16 = (value) => {
+    view.setUint16(cursor, value, true);
+    cursor += 2;
+  };
+  const u32 = (value) => {
+    view.setUint32(cursor, value >>> 0, true);
+    cursor += 4;
+  };
+  const raw = (bytes) => {
+    buffer.set(bytes, cursor);
+    cursor += bytes.length;
+  };
+  for (const entry of prepared) {
+    entry.offset = cursor;
+    u32(67324752);
+    u16(20);
+    u16(2048);
+    u16(0);
+    u16(time);
+    u16(date);
+    u32(entry.crc);
+    u32(entry.dataBytes.length);
+    u32(entry.dataBytes.length);
+    u16(entry.nameBytes.length);
+    u16(0);
+    raw(entry.nameBytes);
+    raw(entry.dataBytes);
+  }
+  const centralStart = cursor;
+  for (const entry of prepared) {
+    u32(33639248);
+    u16(20);
+    u16(20);
+    u16(2048);
+    u16(0);
+    u16(time);
+    u16(date);
+    u32(entry.crc);
+    u32(entry.dataBytes.length);
+    u32(entry.dataBytes.length);
+    u16(entry.nameBytes.length);
+    u16(0);
+    u16(0);
+    u16(0);
+    u16(0);
+    u32(0);
+    u32(entry.offset);
+    raw(entry.nameBytes);
+  }
+  const centralEnd = cursor;
+  u32(101010256);
+  u16(0);
+  u16(0);
+  u16(prepared.length);
+  u16(prepared.length);
+  u32(centralEnd - centralStart);
+  u32(centralStart);
+  u16(0);
+  return new Blob([buffer], { type: "application/zip" });
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/media/collectAttachments.ts
+var ENVELOPE_KEYS = /* @__PURE__ */ new Set(["@context", "credentials", "proof", "issuer", "issuanceDate", "expirationDate"]);
+function toAttachment(raw, allowBareString) {
+  if (!raw) return null;
+  if (typeof raw === "object" && typeof raw.content === "string") {
+    const obj = raw;
+    const resolved = resolveClaimFileRef(obj.content);
+    if (!resolved) return null;
+    return {
+      name: typeof obj.name === "string" ? obj.name : "file",
+      type: typeof obj.type === "string" ? obj.type : "",
+      content: resolved
+    };
+  }
+  if (typeof raw === "string" && allowBareString) {
+    const resolved = resolveClaimFileRef(raw);
+    if (!resolved) return null;
+    const name = resolved.split("/").pop()?.split("?")[0] || "file";
+    return { name, type: "", content: resolved };
+  }
+  return null;
+}
+function collectClaimAttachments(credentialSubject, surveyModel) {
+  if (!credentialSubject || typeof credentialSubject !== "object") return [];
+  const questionTitles = /* @__PURE__ */ new Map();
+  const fileQuestionNames = /* @__PURE__ */ new Set();
+  if (surveyModel) {
+    for (const q of surveyModel.getAllQuestions(false, false, true)) {
+      const qType = (q.getType?.() || "").toLowerCase();
+      const name = q.name;
+      if (name) questionTitles.set(name, q.title || name);
+      if (qType === "file" || qType === "signaturepad" || qType === "image") {
+        fileQuestionNames.add(name);
+      }
+    }
+  }
+  const result = [];
+  const seenContent = /* @__PURE__ */ new Set();
+  const push = (label, file) => {
+    if (seenContent.has(file.content)) return;
+    seenContent.add(file.content);
+    result.push({ ...file, label });
+  };
+  const pushFrom = (key, value) => {
+    const allowBare = fileQuestionNames.has(key);
+    const entries = Array.isArray(value) ? value : [value];
+    const files = entries.map((v) => toAttachment(v, allowBare)).filter((f) => !!f);
+    if (!files.length) return false;
+    const label = questionTitles.get(key) || key;
+    for (const f of files) push(label, f);
+    return true;
+  };
+  const seenRootKeys = /* @__PURE__ */ new Set();
+  for (const name of fileQuestionNames) {
+    if (credentialSubject[name] !== void 0) {
+      pushFrom(name, credentialSubject[name]);
+      seenRootKeys.add(name);
+    }
+  }
+  const walk = (node, isRoot) => {
+    if (!node || typeof node !== "object") return;
+    for (const [key, value] of Object.entries(node)) {
+      if (isRoot && seenRootKeys.has(key)) continue;
+      if (ENVELOPE_KEYS.has(key)) continue;
+      if (!pushFrom(key, value) && value && typeof value === "object") walk(value, false);
+    }
+  };
+  walk(credentialSubject, true);
+  return result;
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/media/mediaNaming.ts
+var MEDIA_DIR = "media";
+var MEDIA_SEPARATOR = "__";
+var SEQ_DIGITS = 4;
+var REF_MAX = 14;
+var FIELD_MAX = 32;
+var NAME_MAX = 48;
+var WINDOWS_RESERVED = /^(con|prn|aux|nul|com\d|lpt\d)$/i;
+function sanitizeSegment(value, maxLength) {
+  const out = String(value ?? "").replace(/[^A-Za-z0-9.-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, maxLength).replace(/[-.]+$/g, "");
+  return out;
+}
+function splitExtension(fileName) {
+  const dot = fileName.lastIndexOf(".");
+  if (dot <= 0 || dot === fileName.length - 1) return { stem: fileName, ext: "" };
+  const ext = fileName.slice(dot + 1);
+  if (!/^[A-Za-z0-9]{1,5}$/.test(ext)) return { stem: fileName, ext: "" };
+  return { stem: fileName.slice(0, dot), ext };
+}
+var MIME_EXTENSIONS = {
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/png": "png",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "image/bmp": "bmp",
+  "image/heic": "heic",
+  "application/pdf": "pdf",
+  "application/msword": "doc",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.ms-excel": "xls",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov",
+  "audio/mpeg": "mp3",
+  "audio/wav": "wav",
+  "audio/ogg": "ogg"
+};
+function resolveExtension(originalName, mimeType) {
+  const key = String(mimeType || "").split(";")[0].trim().toLowerCase();
+  const fromMime = MIME_EXTENSIONS[key];
+  if (fromMime) return fromMime;
+  const fromName = splitExtension(originalName).ext;
+  return fromName ? fromName.toLowerCase() : "bin";
+}
+function buildMediaFileName(parts) {
+  const seq = String(Math.max(0, Math.trunc(parts.seq))).padStart(SEQ_DIGITS, "0");
+  const ref = sanitizeSegment(parts.recordId, REF_MAX) || "record";
+  const field = sanitizeSegment(parts.fieldName, FIELD_MAX) || "field";
+  const idx = String(Math.max(1, Math.trunc(parts.fileIndex))).padStart(2, "0");
+  const original = String(parts.originalName || "").trim();
+  const { stem } = splitExtension(original);
+  let name = sanitizeSegment(stem, NAME_MAX);
+  if (!name || WINDOWS_RESERVED.test(name)) name = "file";
+  const ext = resolveExtension(original, parts.mimeType);
+  return [seq, ref, field, idx, name].join(MEDIA_SEPARATOR) + `.${ext}`;
+}
+function buildMediaPath(parts) {
+  return `${MEDIA_DIR}/${buildMediaFileName(parts)}`;
+}
+function dedupeMediaPath(path, taken) {
+  if (!taken.has(path)) {
+    taken.add(path);
+    return path;
+  }
+  const dot = path.lastIndexOf(".");
+  const stem = dot > 0 ? path.slice(0, dot) : path;
+  const ext = dot > 0 ? path.slice(dot) : "";
+  for (let n = 2; n < 1e3; n += 1) {
+    const candidate = `${stem}-${n}${ext}`;
+    if (!taken.has(candidate)) {
+      taken.add(candidate);
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find a unique archive path for ${path}`);
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/media/collectMedia.ts
+function isFileEntry(value) {
+  return !!value && typeof value === "object" && typeof value.content === "string";
+}
+function fileEntriesOf(value) {
+  if (Array.isArray(value)) return value.filter(isFileEntry);
+  return isFileEntry(value) ? [value] : [];
+}
+function formatFieldPath(path, withIndexes = true) {
+  return path.reduce((out, segment) => {
+    if (typeof segment === "number") return `${out}[${withIndexes ? segment : ""}]`;
+    return out ? `${out}.${segment}` : segment;
+  }, "");
+}
+function collectRecordMedia(answers, record, options = {}) {
+  if (!answers || typeof answers !== "object") return [];
+  const taken = options.takenPaths ?? /* @__PURE__ */ new Set();
+  const titles = options.titlesByFieldName ?? {};
+  const refs = [];
+  const filesSeenByQuestion = /* @__PURE__ */ new Map();
+  const collect = (entries, valuePath) => {
+    const fieldName = String(valuePath[0]);
+    const questionName = String([...valuePath].reverse().find((segment) => typeof segment === "string") ?? fieldName);
+    const questionShape = formatFieldPath(valuePath, false);
+    for (const entry of entries) {
+      const fileIndex = (filesSeenByQuestion.get(questionShape) ?? 0) + 1;
+      filesSeenByQuestion.set(questionShape, fileIndex);
+      const sourceUrl = resolveClaimFileRef(entry.content);
+      if (!sourceUrl) continue;
+      const originalName = typeof entry.name === "string" ? entry.name : "";
+      const mimeType = typeof entry.type === "string" ? entry.type : "";
+      const archivePath = dedupeMediaPath(buildMediaPath({ seq: record.seq, recordId: record.recordId, fieldName: questionName, fileIndex, originalName, mimeType }), taken);
+      refs.push({
+        seq: record.seq,
+        recordId: record.recordId,
+        fieldName,
+        fieldPath: formatFieldPath(valuePath),
+        valuePath,
+        fieldTitle: titles[questionName] || questionName,
+        fileIndex,
+        originalName,
+        mimeType,
+        sourceUrl,
+        archivePath
+      });
+    }
+  };
+  const visitChildren = (node, valuePath) => {
+    for (const [key, child] of Object.entries(node)) {
+      if (!ENVELOPE_KEYS.has(key)) visit(child, [...valuePath, key]);
+    }
+  };
+  const visit = (value, valuePath) => {
+    const entries = fileEntriesOf(value);
+    if (entries.length > 0) {
+      collect(entries, valuePath);
+    } else if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(item, [...valuePath, index]));
+    } else if (value && typeof value === "object") {
+      visitChildren(value, valuePath);
+    }
+  };
+  visitChildren(answers, []);
+  return refs;
+}
+function withValueAt(node, path, value) {
+  if (path.length === 0) return value;
+  const [head, ...rest] = path;
+  if (Array.isArray(node)) {
+    const copy2 = [...node];
+    copy2[Number(head)] = withValueAt(copy2[Number(head)], rest, value);
+    return copy2;
+  }
+  const copy = { ...node };
+  copy[head] = withValueAt(copy[head], rest, value);
+  return copy;
+}
+function replaceFileValuesWithPaths(answers, refs, failedPaths) {
+  if (refs.length === 0) return answers;
+  const byValue = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const key = JSON.stringify(ref.valuePath);
+    const group = byValue.get(key) ?? { valuePath: ref.valuePath, cells: [] };
+    group.cells.push(failedPaths?.has(ref.archivePath) ? `${ref.originalName || ref.archivePath} (download failed \u2014 not in archive)` : ref.archivePath);
+    byValue.set(key, group);
+  }
+  let out = answers;
+  for (const { valuePath, cells } of byValue.values()) out = withValueAt(out, valuePath, cells.join("; "));
+  return out;
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/buildExportBundle.ts
+var DEFAULT_CONCURRENCY = 6;
+var DEFAULT_RETRY = {
+  maxAttempts: 6,
+  baseDelayMs: 5e3,
+  maxDelayMs: 6e4,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+async function mapWithLimit(items, limit, worker) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const runners = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    for (; ; ) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) return;
+      results[index] = await worker(items[index], index);
+    }
+  });
+  await Promise.all(runners);
+  return results;
+}
+function retryDelayMs(err, attempt, policy) {
+  const { status, retryAfterMs } = err ?? {};
+  if (typeof status !== "number" || status !== 429 && status < 500) return null;
+  if (typeof retryAfterMs === "number" && retryAfterMs > 0) return Math.min(retryAfterMs, policy.maxDelayMs);
+  return Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
+}
+function createCooldown(sleep) {
+  let resumeAt = 0;
+  return {
+    wait: async () => {
+      const remaining = resumeAt - Date.now();
+      if (remaining > 0) await sleep(remaining);
+    },
+    extend: (ms) => {
+      resumeAt = Math.max(resumeAt, Date.now() + ms);
+    }
+  };
+}
+async function fetchMediaBlob(url, fetchMedia) {
+  if (fetchMedia) return fetchMedia(url);
+  const response = await fetch(url);
+  if (!response.ok) throw Object.assign(new Error(`gateway returned ${response.status} ${response.statusText}`.trim()), { status: response.status });
+  return response.blob();
+}
+async function downloadMedia(ref, fetchMedia, policy, cooldown) {
+  for (let attempt = 1; ; attempt += 1) {
+    await cooldown.wait();
+    try {
+      const blob = await fetchMediaBlob(ref.sourceUrl, fetchMedia);
+      return { bytes: new Uint8Array(await blob.arrayBuffer()), reason: "" };
+    } catch (err) {
+      const delay = attempt < policy.maxAttempts ? retryDelayMs(err, attempt, policy) : null;
+      if (delay === null) return { bytes: null, reason: err instanceof Error ? err.message : "download failed" };
+      cooldown.extend(delay);
+    }
+  }
+}
+async function buildExportBundle(params) {
+  const takenPaths = /* @__PURE__ */ new Set();
+  const refs = [];
+  const refsByRecordId = /* @__PURE__ */ new Map();
+  params.records.forEach((record, index) => {
+    const recordRefs = collectRecordMedia(record.answers, { seq: index + 1, recordId: record.recordId }, { titlesByFieldName: params.titlesByFieldName, takenPaths });
+    refs.push(...recordRefs);
+    refsByRecordId.set(record.recordId, recordRefs);
+  });
+  const manifestByRecordId = new Map(params.records.map((record) => [record.recordId, record.manifest ?? {}]));
+  const policy = { ...DEFAULT_RETRY, ...params.retry };
+  const cooldown = createCooldown(policy.sleep);
+  const downloads = await mapWithLimit(refs, params.concurrency ?? DEFAULT_CONCURRENCY, (ref) => downloadMedia(ref, params.fetchMedia, policy, cooldown));
+  const failedPaths = new Set(refs.filter((_, index) => !downloads[index].bytes).map((ref) => ref.archivePath));
+  const answersByRecordId = {};
+  for (const record of params.records) {
+    answersByRecordId[record.recordId] = replaceFileValuesWithPaths(record.answers, refsByRecordId.get(record.recordId) ?? [], failedPaths);
+  }
+  const entries = [];
+  const manifestRows = [];
+  const failures = [];
+  refs.forEach((ref, index) => {
+    const { bytes, reason } = downloads[index];
+    if (bytes) {
+      entries.push({ path: ref.archivePath, data: bytes });
+    } else {
+      failures.push({ archivePath: ref.archivePath, sourceUrl: ref.sourceUrl, reason });
+    }
+    manifestRows.push({
+      archivePath: bytes ? ref.archivePath : "",
+      ...manifestByRecordId.get(ref.recordId),
+      recordId: ref.recordId,
+      fieldName: ref.fieldName,
+      fieldPath: ref.fieldPath,
+      fieldTitle: ref.fieldTitle,
+      fileIndex: ref.fileIndex,
+      originalName: ref.originalName,
+      mimeType: ref.mimeType,
+      sizeBytes: bytes ? bytes.length : "",
+      sourceUrl: ref.sourceUrl,
+      downloadStatus: bytes ? "ok" : "failed",
+      downloadError: reason
+    });
+  });
+  entries.unshift({ path: params.csvName, data: UTF8_BOM + params.renderCsv(answersByRecordId) });
+  entries.splice(1, 0, {
+    path: params.manifestName || "media-manifest.csv",
+    data: UTF8_BOM + (manifestRows.length > 0 ? rowsToCsv(manifestRows) : "note\r\nNo media was submitted for these records.")
+  });
+  return { blob: createZipBlob(entries), mediaTotal: refs.length, mediaFailed: failures.length, failures };
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/baseClaimSubmitters.ts
+var BASE_CLAIM_KEY = /(^|:)baseClaimCID$/i;
+var CID = /baf[a-z0-9]{20,}/i;
+var NAME_LOOKUP_CONCURRENCY = 4;
+var EMPTY_BASE_CLAIM_SUBMITTER = {
+  baseClaimSubmitterDid: "",
+  baseClaimSubmitterAddress: "",
+  baseClaimSubmitterName: ""
+};
+function baseClaimCidOf(answers) {
+  for (const [key, value] of Object.entries(answers)) {
+    if (BASE_CLAIM_KEY.test(key) && typeof value === "string") return value.match(CID)?.[0] ?? "";
+  }
+  return "";
+}
+async function resolveBaseClaimSubmitters(answersByClaimId, handlers) {
+  const baseCidByClaimId = Object.entries(answersByClaimId).map(([claimId, answers]) => [claimId, baseClaimCidOf(answers)]).filter(([, baseCid]) => baseCid);
+  if (baseCidByClaimId.length === 0 || !handlers.getClaimsByIds) return {};
+  const baseClaims = await handlers.getClaimsByIds([...new Set(baseCidByClaimId.map(([, baseCid]) => baseCid))]);
+  const baseClaimByCid = new Map(baseClaims.map((claim) => [claim.claimId, claim]));
+  const submitterDids = [...new Set(baseClaims.map((claim) => claim.agentDid).filter(Boolean))];
+  const names = await mapWithLimit(submitterDids, NAME_LOOKUP_CONCURRENCY, async (did) => {
+    try {
+      return (await handlers.getMatrixInfoPerDid?.(did))?.displayname || "";
+    } catch {
+      return "";
+    }
+  });
+  const nameByDid = new Map(submitterDids.map((did, index) => [did, names[index]]));
+  return Object.fromEntries(
+    baseCidByClaimId.map(([claimId, baseCid]) => {
+      const baseClaim = baseClaimByCid.get(baseCid);
+      if (!baseClaim) return [claimId, EMPTY_BASE_CLAIM_SUBMITTER];
+      return [
+        claimId,
+        {
+          baseClaimSubmitterDid: baseClaim.agentDid || "",
+          baseClaimSubmitterAddress: baseClaim.agentAddress || "",
+          baseClaimSubmitterName: nameByDid.get(baseClaim.agentDid) || ""
+        }
+      ];
+    })
+  );
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/buildClaimRows.ts
+function claimAnswers(contents) {
+  const raw = contents;
+  const subject = raw?.credentialSubject ?? raw;
+  return subject && typeof subject === "object" && !Array.isArray(subject) ? subject : {};
+}
+function buildClaimRows(claims, contentsByClaimId, options = {}) {
+  const baseClaimSubmitters = options.baseClaimSubmittersByClaimId ?? {};
+  const withBaseClaimColumns = Object.keys(baseClaimSubmitters).length > 0;
+  return claims.map((claim) => {
+    const answers = options.answersByClaimId?.[claim.claimId] ?? claimAnswers(contentsByClaimId[claim.claimId]);
+    const status = getClaimStatusInfo(claim);
+    return {
+      claimId: claim.claimId,
+      collectionId: claim.collectionId,
+      agentDid: claim.agentDid,
+      agentAddress: claim.agentAddress,
+      submissionDate: claim.submissionDate,
+      status: status.key,
+      // A terminal decision outranks a dispute in `status`, but the dispute
+      // record stays on chain — keep it visible rather than losing it.
+      hasDispute: !!claim.disputeBySubjectId,
+      schemaType: claim.schemaType ?? "",
+      ...withBaseClaimColumns ? baseClaimSubmitters[claim.claimId] ?? EMPTY_BASE_CLAIM_SUBMITTER : {},
+      ...answers
+    };
+  });
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/buildGranteeRows.ts
+function buildGranteeRows(grantees, namesByDid = {}) {
+  return grantees.map((grantee) => {
+    const did = grantee.did || "";
+    return {
+      name: namesByDid[did] || "",
+      did,
+      address: grantee.address,
+      role: grantee.role,
+      agentQuota: grantee.agentQuota ?? "",
+      maxAmount: Array.isArray(grantee.maxAmount) ? grantee.maxAmount.map((coin) => `${coin.amount} ${coin.denom}`).join("; ") : ""
+    };
+  });
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/buildCollectionMembersSections.ts
+var OPEN_ONLY_NOTE = "Open bids only \u2014 the bids service drops a bid from its query response once it is approved or rejected, and this host cannot read decided bids from the collection room.";
+var FULL_HISTORY_NOTE = "All bids, open and decided. See bidState: open = awaiting decision, granted = decided with a live grant, lapsed = decided with NO active grant.";
+function buildCollectionMembersSections(params) {
+  const { grantees, bids, namesByDid = {}, collectionId, bidsTruncated, decidedBidsIncluded } = params;
+  const label = collectionId ? ` (collection ${collectionId})` : "";
+  const scopeNote = decidedBidsIncluded ? FULL_HISTORY_NOTE : OPEN_ONLY_NOTE;
+  const truncationNote = bidsTruncated ? " WARNING: paging stopped early \u2014 this list is incomplete." : "";
+  return [
+    {
+      title: `PART 1 \u2014 ACTIVE GRANTS${label}`,
+      rows: buildGranteeRows(grantees, namesByDid),
+      emptyNote: "No active grants on this collection."
+    },
+    {
+      title: `PART 2 \u2014 ${decidedBidsIncluded ? "BIDS" : "OPEN BIDS"}${label} \u2014 ${scopeNote}${truncationNote}`,
+      rows: buildBidRows(bids, grantees, { namesByDid, ...params.bidOptions }),
+      emptyNote: decidedBidsIncluded ? "No bids have been submitted to this collection." : "No open bids on this collection."
+    }
+  ];
+}
+
+// src/mantine/blocks/action/actionTypes/_shared/dataExport/exportFileNames.ts
+var slug = (value, fallback) => value ? String(value).replace(/[^A-Za-z0-9._-]+/g, "-") : fallback;
+var exportFileNames = {
+  claims(collectionId) {
+    const id = slug(collectionId, "collection");
+    return { csv: `claims-${id}.csv`, manifest: `media-manifest-${id}.csv`, zip: `claims-${id}-${timestampSuffix()}.zip` };
+  },
+  claim(claimId) {
+    const id = slug(claimId, "claim").slice(0, 20);
+    return { csv: `claim-${id}.csv`, manifest: `media-manifest-${id}.csv`, zip: `claim-${id}-${timestampSuffix()}.zip` };
+  },
+  bids(collectionId) {
+    const id = slug(collectionId, "collection");
+    return { csv: `bids-${id}.csv`, manifest: `media-manifest-${id}.csv`, zip: `bids-${id}-${timestampSuffix()}.zip` };
+  },
+  bid(bidId) {
+    const id = slug(bidId, "bid").slice(0, 20);
+    return { csv: `bid-${id}.csv`, manifest: `media-manifest-${id}.csv`, zip: `bid-${id}-${timestampSuffix()}.zip` };
+  },
+  collectionMembers(collectionId) {
+    const id = slug(collectionId, "collection");
+    return { csv: `collection-members-${id}.csv`, manifest: `media-manifest-${id}.csv`, zip: `collection-members-${id}-${timestampSuffix()}.zip` };
+  }
+};
+
+// src/mantine/components/MediaPreviewModal.tsx
+import React2 from "react";
+import { Anchor, Box, Center, Group, Modal, Stack, Text } from "@mantine/core";
+import { useMediaQuery } from "@mantine/hooks";
+import { IconDownload as IconDownload2 } from "@tabler/icons-react";
+
+// src/mantine/components/mediaPreviewKind.ts
+var IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp"];
+var VIDEO_EXTENSIONS = ["mp4", "webm", "mov", "mkv"];
+var AUDIO_EXTENSIONS = ["mp3", "wav", "ogg", "m4a", "flac"];
+var UNSPECIFIC_CONTENT_TYPES = /* @__PURE__ */ new Set(["", "application/octet-stream", "binary/octet-stream"]);
+function normaliseContentType(contentType) {
+  return (contentType || "").toLowerCase().split(";")[0].trim();
+}
+function dataUrlContentType(content) {
+  return content.startsWith("data:") ? content.slice(5).split(/[;,]/)[0] : void 0;
+}
+function detectMediaKind(type, name) {
+  const t = (type || "").toLowerCase();
+  const ext = (name || "").toLowerCase().split(".").pop() || "";
+  if (t.startsWith("image/") || IMAGE_EXTENSIONS.includes(ext)) return "image";
+  if (t.startsWith("video/") || VIDEO_EXTENSIONS.includes(ext)) return "video";
+  if (t.startsWith("audio/") || AUDIO_EXTENSIONS.includes(ext)) return "audio";
+  if (t === "application/pdf" || ext === "pdf") return "pdf";
+  return "other";
+}
+function kindFromContentType(contentType) {
+  const t = normaliseContentType(contentType);
+  if (t.startsWith("image/")) return "image";
+  if (t.startsWith("video/")) return "video";
+  if (t.startsWith("audio/")) return "audio";
+  if (t === "application/pdf") return "pdf";
+  return "other";
+}
+function resolvePreviewKind(file) {
+  const declared = detectMediaKind(file.type, file.name);
+  const contentType = file.contentType ?? dataUrlContentType(file.content);
+  const fetched = contentType !== void 0 || file.content.startsWith("blob:");
+  if (!fetched) return declared;
+  const actual = kindFromContentType(contentType);
+  if (actual !== "other") return actual;
+  if (UNSPECIFIC_CONTENT_TYPES.has(normaliseContentType(contentType)) && declared !== "pdf") return declared;
+  return "other";
+}
+var MEDIA_FRAME_SANDBOX = "allow-scripts";
+
+// src/mantine/components/MediaPreviewModal.tsx
+var MediaPreviewModal = ({ file, onClose }) => {
+  const isMobile = useMediaQuery("(max-width: 992px)");
+  const opened = !!file;
+  const kind = file ? resolvePreviewKind(file) : "other";
+  const wide = kind === "pdf" || kind === "image" || kind === "video";
+  return /* @__PURE__ */ React2.createElement(
+    Modal,
+    {
+      opened,
+      onClose,
+      zIndex: 1e4,
+      portalProps: typeof document !== "undefined" ? { target: document.body } : void 0,
+      title: /* @__PURE__ */ React2.createElement(Group, { gap: "sm", wrap: "nowrap", style: { width: "100%" } }, /* @__PURE__ */ React2.createElement(Text, { fw: 500, size: "sm", truncate: true, style: { flex: 1, minWidth: 0 } }, file?.name || "Preview"), file && /* @__PURE__ */ React2.createElement(Anchor, { href: file.content, target: "_blank", rel: "noopener noreferrer", download: file.name, size: "xs", c: "dimmed", style: { flexShrink: 0 } }, /* @__PURE__ */ React2.createElement(Box, { style: { display: "inline-flex", alignItems: "center", gap: 4 } }, icon(IconDownload2, 14), "Download"))),
+      size: wide ? "95vw" : "xl",
+      centered: true,
+      styles: wide ? {
+        content: {
+          height: "95vh",
+          maxWidth: isMobile ? "100%" : 1400,
+          display: "flex",
+          flexDirection: "column",
+          overflow: "hidden"
+        },
+        body: {
+          flex: 1,
+          minHeight: 0,
+          display: "flex",
+          flexDirection: "column",
+          overflow: "hidden"
+        }
+      } : void 0
+    },
+    file && /* @__PURE__ */ React2.createElement(Stack, { gap: "sm", style: wide ? { flex: 1, minHeight: 0 } : void 0 }, kind === "image" && /* @__PURE__ */ React2.createElement(Center, { style: { flex: 1, minHeight: 0, overflow: "hidden" } }, /* @__PURE__ */ React2.createElement(
+      "img",
+      {
+        src: file.content,
+        alt: file.name,
+        style: { display: "block", maxWidth: "100%", maxHeight: "100%", width: "auto", height: "auto", objectFit: "contain", borderRadius: 8 }
+      }
+    )), kind === "video" && // eslint-disable-next-line jsx-a11y/media-has-caption
+    /* @__PURE__ */ React2.createElement("video", { src: file.content, controls: true, style: { width: "100%", flex: 1, minHeight: 0, borderRadius: 8, background: "var(--mantine-color-neutralColor-3)" } }), kind === "audio" && /* @__PURE__ */ React2.createElement("audio", { src: file.content, controls: true, style: { width: "100%" } }), kind === "pdf" && /* @__PURE__ */ React2.createElement(Box, { style: { flex: 1, minHeight: 0, borderRadius: 8, overflow: "hidden" } }, /* @__PURE__ */ React2.createElement("iframe", { src: file.content, title: file.name, sandbox: MEDIA_FRAME_SANDBOX, referrerPolicy: "no-referrer", style: { width: "100%", height: "100%", border: "none" } })), kind === "other" && /* @__PURE__ */ React2.createElement(Center, { p: "xl" }, /* @__PURE__ */ React2.createElement(Text, { size: "sm", c: "dimmed" }, "This file type can't be previewed inline. Use Download above.")))
+  );
+};
+
+export {
+  DownloadCsvButton,
+  DownloadZipButton,
+  getBidStatusInfo,
+  bidAnswers,
+  buildBidRows,
+  collectClaimAttachments,
+  buildExportBundle,
+  resolveBaseClaimSubmitters,
+  claimAnswers,
+  buildClaimRows,
+  buildCollectionMembersSections,
+  exportFileNames,
+  MediaPreviewModal
+};
+//# sourceMappingURL=chunk-JBBFSORW.js.map