@arbidocs/react 0.5.61 → 0.5.63

package/dist/chunk-4DTTEUVY.js

@@ -0,0 +1,1042 @@
+import { useDocumentTools, SIGNED_LOCKED_REASON, fetchMarkupPdf, fetchDocumentFile, fetchDocumentPdf } from './chunk-SI7DJWBT.js';
+import { mergeLayers, AnnotationStoreOfflineError } from './chunk-T4CLW3DN.js';
+import { parseLayer, emptyLayer, LAYER_SCHEMA_VERSION } from './chunk-T3USOSVN.js';
+import { documentBytesKey, arbiQueryKeys } from './chunk-AOEJ744V.js';
+import { useArbiHost } from './chunk-R7YNABZY.js';
+import { parseVersionRef } from './chunk-NNWMHMEC.js';
+import { useMemo, useState, useCallback, useEffect, useSyncExternalStore } from 'react';
+import { onlineManager, useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { unlockIdentityWithPassword, signMessage, getUserEncryptionKeypair, sealedBoxDecrypt, sealedBoxEncrypt, initSodium } from '@arbidocs/client';
+import { workspaces } from '@arbidocs/sdk/browser';
+
+// src/document-tools/markup-store.ts
+var MAX_MERGE_ATTEMPTS = 5;
+var KEEPALIVE_LIMIT = 6e4;
+var MarkupStoreError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "MarkupStoreError";
+  }
+  status;
+};
+var detailOf = (error, fallback) => {
+  const detail3 = error?.detail;
+  return typeof detail3 === "string" ? detail3 : fallback;
+};
+async function call(request) {
+  try {
+    return await request();
+  } catch (e) {
+    if (e instanceof TypeError || typeof navigator !== "undefined" && !navigator.onLine) {
+      throw new AnnotationStoreOfflineError();
+    }
+    throw e;
+  }
+}
+function createMarkupStore({ version, client, onSaved }) {
+  let revision = 0;
+  let count = 0;
+  let canEdit = false;
+  let base = null;
+  const seen = /* @__PURE__ */ new Set();
+  const remember = (layer) => {
+    for (const a of layer.annotations) seen.add(a.id);
+  };
+  const query = version ? { version } : {};
+  async function read(documentId, ifNoneMatch) {
+    const { data, error, response } = await call(
+      () => client.GET("/v1/document/{document_ext_id}/markup", {
+        params: { path: { document_ext_id: documentId }, query },
+        headers: ifNoneMatch === void 0 ? void 0 : { "If-None-Match": `"${ifNoneMatch}"` }
+      })
+    );
+    if (response.status === 304) return null;
+    if (error || !data) {
+      throw new MarkupStoreError(
+        detailOf(error, `The markup could not be loaded (${response.status})`),
+        response.status
+      );
+    }
+    const layer = parseLayer({
+      schema: LAYER_SCHEMA_VERSION,
+      documentId,
+      annotations: data.annotations ?? [],
+      updatedAt: data.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { revision: data.revision ?? 0, layer, canEdit: !!data.can_edit };
+  }
+  function adopt(server) {
+    revision = server.revision;
+    canEdit = server.canEdit;
+    base = server.layer;
+    count = server.layer.annotations.length;
+    remember(server.layer);
+  }
+  async function put(layer, from) {
+    return call(
+      () => client.PUT("/v1/document/{document_ext_id}/markup", {
+        params: { path: { document_ext_id: layer.documentId }, query },
+        headers: { "If-Match": `"${from}"` },
+        body: { annotations: layer.annotations, base_revision: from },
+        // A save started as the page closes must outlive it; browsers cap such bodies at 64 KB.
+        keepalive: JSON.stringify(layer.annotations).length < KEEPALIVE_LIMIT
+      })
+    );
+  }
+  return {
+    snapshot: () => ({ revision, count, canEdit }),
+    canEdit: () => canEdit,
+    async load(documentId) {
+      const server = await read(documentId);
+      if (!server) throw new MarkupStoreError("The markup could not be loaded");
+      adopt(server);
+      return server.layer;
+    },
+    async save(layer) {
+      remember(layer);
+      let mine = layer;
+      for (let attempt = 0; attempt < MAX_MERGE_ATTEMPTS; attempt++) {
+        const { data, error, response } = await put(mine, revision);
+        if (response.ok && data) {
+          revision = data.revision;
+          count = data.count;
+          base = mine;
+          remember(mine);
+          onSaved?.({ revision, count, canEdit });
+          return mine;
+        }
+        if (response.status === 409) {
+          const latest = await read(layer.documentId);
+          if (!latest) throw new MarkupStoreError("The markup could not be re-read");
+          const deleted = new Set(
+            [...seen].filter((id) => !mine.annotations.some((a) => a.id === id))
+          );
+          const merged = mergeLayers({ base, mine, theirs: latest.layer, deleted });
+          revision = latest.revision;
+          canEdit = latest.canEdit;
+          base = latest.layer;
+          remember(latest.layer);
+          mine = merged;
+          continue;
+        }
+        if (response.status === 403) canEdit = false;
+        throw new MarkupStoreError(
+          detailOf(error, `The markup could not be saved (${response.status})`),
+          response.status
+        );
+      }
+      throw new MarkupStoreError("The markup keeps changing; it will be saved on the next edit");
+    },
+    async pull(documentId) {
+      const server = await read(documentId, revision);
+      if (!server || server.revision === revision) return null;
+      adopt(server);
+      return server.layer;
+    }
+  };
+}
+
+// src/document-tools/markup-transfer.ts
+var LEGACY_LAYER_PREFIX = "arbi:annotations:";
+function storage() {
+  try {
+    return typeof localStorage === "undefined" ? void 0 : localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function readLegacyLayer(documentId) {
+  try {
+    const raw = storage()?.getItem(LEGACY_LAYER_PREFIX + documentId);
+    if (!raw) return null;
+    return parseLayer(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function forgetLegacyLayer(documentId) {
+  try {
+    storage()?.removeItem(LEGACY_LAYER_PREFIX + documentId);
+  } catch {
+  }
+}
+function marksByVersion(layer, versions) {
+  const sorted = [...versions].sort((a, b) => a.n - b.n);
+  const out = /* @__PURE__ */ new Map();
+  for (const mark of layer.annotations) {
+    const at = Date.parse(mark.createdAt);
+    let target = sorted[0]?.n ?? 1;
+    for (const v of sorted) {
+      const created = v.created_at ? Date.parse(v.created_at) : Number.NaN;
+      if (!Number.isNaN(created) && !Number.isNaN(at) && created <= at) target = v.n;
+    }
+    out.set(target, [...out.get(target) ?? [], mark]);
+  }
+  return out;
+}
+async function addToMarkup(documentId, version, marks, client) {
+  const store = createMarkupStore({ version, client });
+  const current = await store.load(documentId);
+  const incoming = {
+    ...emptyLayer(documentId, (/* @__PURE__ */ new Date()).toISOString()),
+    annotations: marks
+  };
+  const merged = mergeLayers({ base: null, mine: current, theirs: incoming });
+  const added = merged.annotations.length - current.annotations.length;
+  if (added > 0) await store.save(parseLayer({ ...merged, schema: LAYER_SCHEMA_VERSION }));
+  return added;
+}
+async function migrateLegacyLayer(documentId, layer, versions, currentVersion, client) {
+  let added = 0;
+  for (const [n, marks] of marksByVersion(layer, versions.length ? versions : [{ n: 1 }])) {
+    added += await addToMarkup(documentId, n === currentVersion ? void 0 : n, marks, client);
+  }
+  forgetLegacyLayer(documentId);
+  return added;
+}
+async function openThreadsOf(documentId, version, client) {
+  const layer = await createMarkupStore({ version, client }).load(documentId);
+  return layer.annotations.filter((a) => a.kind === "comment" && !a.resolved);
+}
+async function copyOpenThreads(documentId, fromVersion, client) {
+  const threads = await openThreadsOf(documentId, fromVersion, client);
+  if (!threads.length) return 0;
+  return addToMarkup(documentId, void 0, threads, client);
+}
+function versionsWithMarkup(versions) {
+  return (versions ?? []).filter((v) => (v.markup_count ?? 0) > 0);
+}
+var SIGNED_UNCHANGED = "The signed PDF is unchanged: the comments are kept beside it as markup.";
+function useDocumentMarkup(documentData, snapshotVersion, currentSigned = false) {
+  const { client, notify, saveFile, onDocumentsChanged } = useDocumentTools();
+  const documentId = documentData?.external_id;
+  const currentVersion = documentData?.current_version ?? 1;
+  const shownVersion = snapshotVersion ?? currentVersion;
+  const versions = useMemo(() => documentData?.versions ?? [], [documentData?.versions]);
+  const [localCounts, setLocalCounts] = useState({});
+  const countOf = useCallback(
+    (n) => localCounts[`${documentId}@${n}`] ?? versions.find((v) => v.n === n)?.markup_count ?? 0,
+    [localCounts, documentId, versions]
+  );
+  const hasMarkup = countOf(shownVersion) > 0;
+  const [showOriginal, setShowOriginal] = useState(false);
+  useEffect(() => setShowOriginal(false), [documentId, snapshotVersion]);
+  const refresh = useCallback(() => {
+    if (!documentId || !onDocumentsChanged) return;
+    Promise.resolve(onDocumentsChanged([documentId], "markup")).catch(
+      (e) => console.warn("Could not refresh the document after a markup change", e)
+    );
+  }, [documentId, onDocumentsChanged]);
+  const onMarkupChange = useCallback(
+    (snapshot) => {
+      if (!documentId) return;
+      const key = `${documentId}@${shownVersion}`;
+      if (countOf(shownVersion) > 0 !== snapshot.count > 0) refresh();
+      setLocalCounts((counts) => ({ ...counts, [key]: snapshot.count }));
+    },
+    [documentId, shownVersion, countOf, refresh]
+  );
+  const downloadMarkup = useCallback(async () => {
+    if (!documentId) return;
+    if (currentSigned) {
+      notify(SIGNED_LOCKED_REASON, "info");
+      return;
+    }
+    try {
+      const { blob, fileName } = await fetchMarkupPdf(
+        client,
+        documentId,
+        snapshotVersion ? snapshotVersion : void 0
+      );
+      saveFile(blob, fileName);
+    } catch (e) {
+      notify(e instanceof Error ? e.message : "The markup could not be downloaded", "error");
+    }
+  }, [client, documentId, snapshotVersion, saveFile, notify, currentSigned]);
+  const [legacyCount, setLegacyCount] = useState(0);
+  const [migrating, setMigrating] = useState(false);
+  const shared = documentData?.shared;
+  const loaded = !!documentData;
+  const migrate = useCallback(async () => {
+    if (!documentId) return;
+    const layer = readLegacyLayer(documentId);
+    if (!layer) return;
+    setMigrating(true);
+    try {
+      const added = await migrateLegacyLayer(documentId, layer, versions, currentVersion, client);
+      setLegacyCount(0);
+      setLocalCounts({});
+      refresh();
+      if (added > 0) {
+        notify(
+          `${added} annotation${added === 1 ? "" : "s"} from this browser saved to the document`,
+          "success",
+          {
+            description: shared ? "They are now part of the shared markup." : "They are saved with the document, visible only to you."
+          }
+        );
+      }
+    } catch (e) {
+      notify(
+        e instanceof Error ? e.message : "The annotations from this browser could not be saved",
+        "error",
+        { description: "They are still kept in this browser; open the document again to retry." }
+      );
+    } finally {
+      setMigrating(false);
+    }
+  }, [client, documentId, versions, currentVersion, refresh, shared, notify]);
+  useEffect(() => {
+    if (!documentId || !loaded) return;
+    const layer = readLegacyLayer(documentId);
+    if (!layer) {
+      setLegacyCount(0);
+      return;
+    }
+    if (layer.annotations.length === 0) {
+      forgetLegacyLayer(documentId);
+      setLegacyCount(0);
+      return;
+    }
+    if (shared) setLegacyCount(layer.annotations.length);
+    else void migrate();
+  }, [documentId, loaded, shared]);
+  const legacyPrompt = legacyCount > 0 && !snapshotVersion ? {
+    count: legacyCount,
+    busy: migrating,
+    add: () => void migrate(),
+    discard: () => {
+      if (documentId) forgetLegacyLayer(documentId);
+      setLegacyCount(0);
+    }
+  } : null;
+  const [copying, setCopying] = useState(false);
+  const olderWithMarkup = versionsWithMarkup(versions).filter((v) => v.n !== currentVersion).sort((a, b) => b.n - a.n)[0];
+  const olderNote = !snapshotVersion && !hasMarkup && olderWithMarkup ? {
+    version: olderWithMarkup.n,
+    busy: copying,
+    signed: currentSigned,
+    copy: () => {
+      if (!documentId) return;
+      setCopying(true);
+      copyOpenThreads(documentId, olderWithMarkup.n, client).then((n) => {
+        if (n > 0) {
+          setLocalCounts((c) => ({ ...c, [`${documentId}@${currentVersion}`]: n }));
+          refresh();
+        }
+        notify(
+          n > 0 ? `${n} open comment thread${n === 1 ? "" : "s"} copied to version ${currentVersion}` : `Version ${olderWithMarkup.n} has no open comments`,
+          n > 0 ? "success" : "info",
+          // The markup is stored beside the version, so the sealed bytes do not change.
+          n > 0 && currentSigned ? { description: SIGNED_UNCHANGED } : void 0
+        );
+      }).catch(
+        (e) => notify(e instanceof Error ? e.message : "The comments could not be copied", "error")
+      ).finally(() => setCopying(false));
+    }
+  } : null;
+  return {
+    hasMarkup,
+    showOriginal,
+    setShowOriginal,
+    onMarkupChange,
+    downloadMarkup,
+    legacyPrompt,
+    olderNote
+  };
+}
+
+// src/document-tools/frozen-copy.ts
+var baseName = (fileName) => (fileName || "document").replace(/\.pdf$/i, "");
+function frozenCopyName(fileName, redacted) {
+  return `${baseName(fileName)} (${redacted ? "redacted" : "annotated"}).pdf`;
+}
+function redactionLogName(fileName) {
+  return `${baseName(fileName)} (redaction log).csv`;
+}
+async function uploadFrozenCopy(upload, bytes, source, redacted) {
+  const file = new File([bytes], frozenCopyName(source.fileName, redacted), {
+    type: "application/pdf"
+  });
+  const query = {
+    derived_from: [source.documentId],
+    derived_role: redacted ? "redaction" : "annotated",
+    shared: source.shared
+  };
+  if (source.folder) query.folder = source.folder;
+  if (source.workspaceId) query.workspace_ext_id = source.workspaceId;
+  const response = await upload({ file, query });
+  return response?.doc_ext_ids?.[0];
+}
+
+// src/document-tools/can-annotate.ts
+function canAnnotate(s) {
+  return s.activeTab === "pdf" && s.hasPdf && !s.isImage && !s.isVideo && !s.isAudio && !s.isDownloadOnly && !s.isDraft && !s.isStreaming && !s.isSnapshot && !s.isComparing;
+}
+function useIsOnline() {
+  return useSyncExternalStore(
+    (onChange) => onlineManager.subscribe(onChange),
+    () => onlineManager.isOnline(),
+    () => true
+  );
+}
+function useDocumentBytes(documentRef, options) {
+  const { client } = useDocumentTools();
+  const { version, kind, enabled = true, fallback } = options;
+  return useQuery({
+    queryKey: documentBytesKey(documentRef, version ?? null, kind),
+    queryFn: async ({ signal }) => {
+      if (fallback && typeof navigator !== "undefined" && navigator.onLine === false) {
+        const offline = await fallback();
+        if (offline) return offline;
+      }
+      try {
+        return await (kind === "original" ? fetchDocumentFile : fetchDocumentPdf)(
+          client,
+          documentRef,
+          { signal }
+        );
+      } catch (error) {
+        const offline = await fallback?.();
+        if (offline) return offline;
+        throw error;
+      }
+    },
+    enabled: enabled && !!documentRef,
+    // 'always' so it still runs offline: the fallback serves a copy kept on this device.
+    networkMode: "always",
+    staleTime: Infinity
+  });
+}
+function intentText(signer) {
+  return `I, ${signer.name.trim()}, sign this document electronically. I intend this electronic signature to have the same effect as my handwritten signature.`;
+}
+async function sha256Hex(blob) {
+  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(await blob.arrayBuffer()));
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toAppearance(box) {
+  return { page: box.page - 1, x: box.rect.x, y: box.rect.y, width: box.rect.w, height: box.rect.h };
+}
+var MIN_SIGNATURE_BOX = { width: 0.3, height: 0.07 };
+function isLegibleSignatureBox(rect) {
+  return rect.w >= MIN_SIGNATURE_BOX.width && rect.h >= MIN_SIGNATURE_BOX.height;
+}
+var SIGNATURES_PATH = "/v1/document/{document_ext_id}/signatures";
+function errorDetail(error, fallback) {
+  const detail3 = error?.detail;
+  return typeof detail3 === "string" ? detail3 : fallback;
+}
+async function fetchDocumentSignatures(client, documentRef) {
+  const { docId, version } = parseVersionRef(documentRef);
+  const { data, error } = await client.GET(SIGNATURES_PATH, {
+    params: { path: { document_ext_id: docId }, ...version ? { query: { version } } : {} }
+  });
+  if (!data) throw new Error(errorDetail(error, "The signatures could not be read"));
+  return data;
+}
+function useDocumentSignatures(documentId, enabled = true) {
+  const { client } = useDocumentTools();
+  const { docId, version } = parseVersionRef(documentId);
+  return useQuery({
+    queryKey: arbiQueryKeys.documentSignatures(docId ?? "", version),
+    queryFn: () => fetchDocumentSignatures(client, documentId),
+    enabled: enabled && !!docId,
+    staleTime: 6e4
+  });
+}
+var SigningError = class extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.name = "SigningError";
+    this.reason = reason;
+  }
+};
+function signingErrorReason(detail3) {
+  if (/still being prepared/i.test(detail3)) return "preparing";
+  if (/no longer the current version/i.test(detail3)) return "stale";
+  return "failed";
+}
+function signingError(error, fallback) {
+  const detail3 = errorDetail(error, fallback);
+  return new SigningError(detail3, signingErrorReason(detail3));
+}
+var PREPARE_RETRIES = 3;
+var PREPARE_RETRY_DELAY_MS = 1500;
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function signDocument(client, deploymentDomain, {
+  documentId,
+  pdfBlob,
+  email,
+  password,
+  signer,
+  appearance,
+  includeDate = false,
+  version
+}) {
+  const path = { document_ext_id: documentId };
+  const body = {
+    signer: { name: signer.name },
+    ...appearance ? { appearance } : {},
+    include_date: includeDate,
+    ...version ? { version } : {}
+  };
+  const prepare = () => client.POST("/v1/document/{document_ext_id}/sign/prepare", { params: { path }, body });
+  let prepared = await prepare();
+  for (let attempt = 0; !prepared.data && attempt < PREPARE_RETRIES; attempt++) {
+    if (signingError(prepared.error, "").reason !== "preparing") break;
+    await wait(PREPARE_RETRY_DELAY_MS);
+    prepared = await prepare();
+  }
+  if (!prepared.data) throw signingError(prepared.error, "Could not prepare signing");
+  const { statement, intent, source_sha256, timestamp } = prepared.data;
+  if (await sha256Hex(pdfBlob) !== source_sha256) {
+    throw new Error("The document changed since it was opened. Reopen it and sign again.");
+  }
+  if (intent !== intentText(signer)) throw new Error("Signing statement mismatch; not signed.");
+  const identity = await unlockIdentityWithPassword(email, password, deploymentDomain);
+  const signed = await client.POST("/v1/document/{document_ext_id}/sign", {
+    params: { path },
+    body: { ...body, timestamp, signature: signMessage(statement, identity) }
+  });
+  if (!signed.data) throw signingError(signed.error, "Signing failed");
+  return signed.data;
+}
+function useSignDocument() {
+  const env = useDocumentTools();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (vars) => {
+      if (!env.deploymentDomain) throw new Error("Signing is not set up: no deployment domain");
+      return signDocument(env.client, env.deploymentDomain, vars);
+    },
+    onSuccess: async (result) => {
+      await env.onDocumentsChanged?.([result.doc_ext_id], "signed");
+      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.documentSignatures() });
+    }
+  });
+}
+var VERIFY_PATH = "/v1/sign/verify/{reference}";
+var REFERENCE = /^sig-[0-9a-f]{32}$/;
+function isSignatureReference(reference) {
+  return !!reference && REFERENCE.test(reference);
+}
+var SignatureVerificationError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "SignatureVerificationError";
+  }
+  status;
+};
+var VERIFY_ERRORS = {
+  404: "No signature has this reference.",
+  429: "Too many checks, try again in a minute."
+};
+async function fetchSignatureVerification(client, reference) {
+  if (!isSignatureReference(reference)) {
+    throw new SignatureVerificationError("This is not a signature reference.");
+  }
+  const { data, response } = await client.GET(VERIFY_PATH, {
+    params: { path: { reference } }
+  });
+  if (!response.ok || !data) {
+    throw new SignatureVerificationError(
+      VERIFY_ERRORS[response.status] ?? "The signature could not be checked right now.",
+      response.status
+    );
+  }
+  return data;
+}
+function useSignatureVerification(reference) {
+  const { client } = useDocumentTools();
+  return useQuery({
+    queryKey: arbiQueryKeys.signatureVerification(reference ?? ""),
+    queryFn: () => fetchSignatureVerification(client, reference),
+    enabled: !!reference,
+    retry: false
+  });
+}
+async function matchSignedCopy(file, verification) {
+  const hash = await sha256Hex(file);
+  if (hash === verification.document_sha256.toLowerCase()) return { kind: "current" };
+  const signature = verification.signatures.find((s) => s.sha256.toLowerCase() === hash);
+  return signature ? { kind: "earlier", signature } : { kind: "none" };
+}
+function useOpenWorkspaceRead() {
+  const arbi = useArbiHost().arbi;
+  const workspaceId = arbi?.hasWorkspace ? arbi.getWorkspaceId() : void 0;
+  const read = (run) => arbi && workspaceId ? arbi.readInWorkspace(workspaceId, run) : run();
+  return { workspaceId, read };
+}
+var SIGNATURE_FIELD_TYPES = [
+  "signature",
+  "initials",
+  "date",
+  "name"
+];
+var FIELD_TYPE_LABELS = {
+  signature: "Signature",
+  initials: "Initials",
+  date: "Date signed",
+  name: "Name"
+};
+var DEFAULT_FIELD_SIZE = {
+  signature: { width: 0.28, height: 0.05 },
+  initials: { width: 0.1, height: 0.04 },
+  date: { width: 0.22, height: 0.028 },
+  name: { width: 0.28, height: 0.028 }
+};
+var SIGNER_PROGRESS_LABELS = {
+  invited: "Invited",
+  registered: "Not opened yet",
+  viewed: "Viewed",
+  signed: "Signed",
+  declined: "Declined"
+};
+var EMAIL = /^[^@\s<>,;]{1,64}@[^@\s<>,;]{1,255}\.[^@\s<>,;]{1,63}$/;
+var isEmailSigner = (signer) => EMAIL.test(signer.trim());
+var MARK_FIELD_TYPES = ["signature", "initials"];
+function detail(error, fallback) {
+  const d = error?.detail;
+  if (typeof d === "string") return d;
+  if (Array.isArray(d) && d[0] && typeof d[0] === "object" && "msg" in d[0]) {
+    return String(d[0].msg);
+  }
+  return fallback;
+}
+function newFieldId() {
+  return `f${Math.random().toString(36).slice(2, 10)}`;
+}
+function initialsOf(name) {
+  return name.split(/\s+/).filter(Boolean).map((part) => part[0].toUpperCase()).join("").slice(0, 4);
+}
+function fieldsInSigningOrder(fields, signer) {
+  return fields.filter((f) => f.signer === signer).sort((a, b) => a.page - b.page || a.y - b.y || a.x - b.x);
+}
+function sendBlocker(fields) {
+  if (fields.length === 0) return "Place at least one field.";
+  const signers = [...new Set(fields.map((f) => f.signer))];
+  for (const signer of signers) {
+    if (!fields.some((f) => f.signer === signer && MARK_FIELD_TYPES.includes(f.type))) {
+      return "Every signer needs a signature or initials field.";
+    }
+  }
+  return null;
+}
+function fieldsFromSuggestions(suggestions, assign, members = /* @__PURE__ */ new Map()) {
+  return suggestions.flatMap((s) => {
+    const email = s.signer_email?.toLowerCase();
+    const signer = email ? members.get(email) ?? email : assign[s.group];
+    if (!signer) return [];
+    return [
+      {
+        id: newFieldId(),
+        type: s.type,
+        page: s.page,
+        x: s.x,
+        y: s.y,
+        width: s.width,
+        height: s.height,
+        signer,
+        required: s.required ?? true
+      }
+    ];
+  });
+}
+function splitSuggestions(suggestions) {
+  return {
+    placed: suggestions.filter((s) => s.source === "anchor"),
+    extras: suggestions.filter((s) => s.source !== "anchor")
+  };
+}
+async function fetchDocumentSignatureRequests(client, documentId) {
+  const { data, error } = await client.GET("/v1/document/{document_ext_id}/signature-requests", {
+    params: { path: { document_ext_id: documentId } }
+  });
+  if (!data) throw new Error(detail(error, "The signature requests could not be read"));
+  return data;
+}
+function useDocumentSignatureRequests(documentId, enabled = true) {
+  const { client } = useDocumentTools();
+  return useQuery({
+    queryKey: arbiQueryKeys.signatureRequestsForDocument(documentId ?? ""),
+    queryFn: () => fetchDocumentSignatureRequests(client, documentId),
+    enabled: enabled && !!documentId,
+    staleTime: 15e3
+  });
+}
+function useSignatureRequestsAwaitingMe(enabled = true) {
+  const { client } = useDocumentTools();
+  const { workspaceId, read } = useOpenWorkspaceRead();
+  return useQuery({
+    queryKey: arbiQueryKeys.signatureRequestsAwaitingMe(workspaceId),
+    queryFn: () => read(async () => {
+      const { data, error } = await client.GET("/v1/signature-requests", {
+        params: { query: { awaiting_me: true } }
+      });
+      if (!data) throw new Error(detail(error, "The signature requests could not be read"));
+      return data;
+    }),
+    enabled,
+    staleTime: 15e3
+  });
+}
+function useSignatureRequest(requestId) {
+  const { client } = useDocumentTools();
+  return useQuery({
+    queryKey: arbiQueryKeys.signatureRequest(requestId ?? ""),
+    queryFn: async () => {
+      const { data, error } = await client.GET("/v1/signature-requests/{request_ext_id}", {
+        params: { path: { request_ext_id: requestId } }
+      });
+      if (!data) throw new Error(detail(error, "The signature request could not be read"));
+      return data;
+    },
+    enabled: !!requestId
+  });
+}
+async function signatureFieldSuggestions(client, documentId, version) {
+  const { data, error } = await client.GET(
+    "/v1/document/{document_ext_id}/signature-fields/suggest",
+    {
+      params: { path: { document_ext_id: documentId }, ...version ? { query: { version } } : {} }
+    }
+  );
+  if (!data) throw new Error(detail(error, "Signature blocks could not be read"));
+  return { fields: data.fields, signers: data.signers ?? [] };
+}
+async function suggestSignatureFields(client, documentId, version) {
+  return (await signatureFieldSuggestions(client, documentId, version)).fields;
+}
+async function saveSignatureRequest(client, { documentId, version, fields, message, requestId, send }) {
+  if (!requestId) {
+    const { data, error } = await client.POST("/v1/document/{document_ext_id}/signature-requests", {
+      params: { path: { document_ext_id: documentId } },
+      body: { fields, message: message || null, send, ...version ? { version } : {} }
+    });
+    if (!data) throw new Error(detail(error, "The signature request could not be saved"));
+    return data;
+  }
+  const path = { request_ext_id: requestId };
+  const updated = await client.PATCH("/v1/signature-requests/{request_ext_id}", {
+    params: { path },
+    body: { fields, message: message ?? null }
+  });
+  if (!updated.data) throw new Error(detail(updated.error, "The draft could not be saved"));
+  if (!send) return updated.data;
+  const sent = await client.POST("/v1/signature-requests/{request_ext_id}/send", {
+    params: { path }
+  });
+  if (!sent.data) throw new Error(detail(sent.error, "The request could not be sent"));
+  return sent.data;
+}
+function useInvalidateRequests() {
+  const queryClient = useQueryClient();
+  return () => queryClient.invalidateQueries({ queryKey: arbiQueryKeys.signatureRequests() });
+}
+function useSaveSignatureRequest() {
+  const { client } = useDocumentTools();
+  const invalidate = useInvalidateRequests();
+  return useMutation({
+    mutationFn: (vars) => saveSignatureRequest(client, vars),
+    onSuccess: invalidate
+  });
+}
+function useVoidSignatureRequest() {
+  const { client } = useDocumentTools();
+  const invalidate = useInvalidateRequests();
+  return useMutation({
+    mutationFn: async (requestId) => {
+      const { data, error } = await client.POST("/v1/signature-requests/{request_ext_id}/void", {
+        params: { path: { request_ext_id: requestId } }
+      });
+      if (!data) throw new Error(detail(error, "The request could not be voided"));
+      return data;
+    },
+    onSuccess: invalidate
+  });
+}
+function useDeclineSignatureRequest() {
+  const { client } = useDocumentTools();
+  const invalidate = useInvalidateRequests();
+  return useMutation({
+    mutationFn: async ({ requestId, reason }) => {
+      const { data, error } = await client.POST("/v1/signature-requests/{request_ext_id}/decline", {
+        params: { path: { request_ext_id: requestId } },
+        body: { reason: reason || null }
+      });
+      if (!data) throw new Error(detail(error, "Could not decline"));
+      return data;
+    },
+    onSuccess: invalidate
+  });
+}
+async function signSignatureRequest(client, deploymentDomain, { request, pdfBlob, email, password, adopted, fields }) {
+  const path = { request_ext_id: request.external_id };
+  const body = { adopted, fields };
+  const prepared = await client.POST("/v1/signature-requests/{request_ext_id}/sign/prepare", {
+    params: { path },
+    body
+  });
+  if (!prepared.data) {
+    throw new SigningError(detail(prepared.error, "Could not prepare signing"), "failed");
+  }
+  const { statement, intent, source_sha256, timestamp } = prepared.data;
+  if (source_sha256 !== request.source_sha256 || await sha256Hex(pdfBlob) !== source_sha256) {
+    throw new SigningError("The document changed since it was sent. Ask for it again.", "stale");
+  }
+  if (intent !== intentText({ name: adopted.name })) {
+    throw new Error("Signing statement mismatch; not signed.");
+  }
+  const identity = await unlockIdentityWithPassword(email, password, deploymentDomain);
+  const signed = await client.POST("/v1/signature-requests/{request_ext_id}/sign", {
+    params: { path },
+    body: { ...body, timestamp, signature: signMessage(statement, identity) }
+  });
+  if (!signed.data) throw new SigningError(detail(signed.error, "Signing failed"), "failed");
+  return signed.data;
+}
+function useSignSignatureRequest() {
+  const env = useDocumentTools();
+  const invalidate = useInvalidateRequests();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (vars) => {
+      if (!env.deploymentDomain) throw new Error("Signing is not set up: no deployment domain");
+      return signSignatureRequest(env.client, env.deploymentDomain, vars);
+    },
+    onSuccess: async (result) => {
+      await invalidate();
+      if (result.completed && result.request.doc_ext_id) {
+        await env.onDocumentsChanged?.([result.request.doc_ext_id], "signed");
+        await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.documentSignatures() });
+      }
+    }
+  });
+}
+function useSignerCandidates(enabled = true) {
+  const { client, user } = useDocumentTools();
+  const { workspaceId, read } = useOpenWorkspaceRead();
+  return useQuery({
+    queryKey: arbiQueryKeys.signatureCandidates(workspaceId ?? ""),
+    queryFn: async () => {
+      const { data, error } = await read(() => client.GET("/v1/workspace/users"));
+      if (!data) throw new Error(detail(error, "The workspace members could not be read"));
+      const people = data.filter((m) => m.user.external_id.startsWith("usr-")).map((m) => ({
+        externalId: m.user.external_id,
+        name: [m.user.given_name, m.user.family_name].filter(Boolean).join(" ") || m.user.email,
+        email: m.user.email,
+        role: String(m.role)
+      }));
+      const me = user?.email?.toLowerCase();
+      return [...people].sort(
+        (a, b) => Number(b.email.toLowerCase() === me) - Number(a.email.toLowerCase() === me)
+      );
+    },
+    enabled,
+    staleTime: 6e4
+  });
+}
+async function inviteSigners(client, documentId, emails) {
+  if (!emails.length) return;
+  const { error, response } = await client.POST("/v1/workspace/users", {
+    body: workspaces.addWorkspaceMembersBody({
+      emails,
+      role: "guest",
+      confirm_invite: true,
+      resource_type: "document",
+      resource_ext_id: documentId
+    })
+  });
+  if (response.status === 409) {
+    throw new Error("Share the document with the workspace before asking others to sign it.");
+  }
+  if (error && response.status !== 404) {
+    throw new Error(detail(error, "The signers could not be invited"));
+  }
+}
+function useInviteSigners() {
+  const { client } = useDocumentTools();
+  const invalidate = useInvalidateRequests();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ documentId, emails }) => inviteSigners(client, documentId, emails),
+    onSuccess: async () => {
+      await invalidate();
+      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.signatureCandidates() });
+    }
+  });
+}
+var INFORMAL_SIGNATURE_NOTE = "Your saved signature or initials are placed as an image on the document.";
+async function keypair(source = getUserEncryptionKeypair) {
+  await initSodium();
+  const pair = await source();
+  if (!pair) throw new Error("Sign in again to use your saved signature.");
+  return pair;
+}
+function detail2(error, fallback) {
+  const d = error?.detail;
+  return typeof d === "string" ? d : fallback;
+}
+async function fetchSavedSignature(client, source) {
+  const { data, error } = await client.GET("/v1/user/signature");
+  if (!data) throw new Error(detail2(error, "Your saved signature could not be read"));
+  if (!data.sealed) return null;
+  const pair = await keypair(source);
+  const json = new TextDecoder().decode(sealedBoxDecrypt(data.sealed, pair.secretKey));
+  return JSON.parse(json);
+}
+async function storeSavedSignature(client, signature, source) {
+  const pair = await keypair(source);
+  const sealed = sealedBoxEncrypt(
+    Uint8Array.from(new TextEncoder().encode(JSON.stringify(signature))),
+    pair.publicKey
+  );
+  const { error, response } = await client.PUT("/v1/user/signature", { body: { sealed } });
+  if (!response.ok) throw new Error(detail2(error, "Your signature could not be saved"));
+}
+async function deleteSavedSignature(client) {
+  const { error, response } = await client.DELETE("/v1/user/signature");
+  if (!response.ok) throw new Error(detail2(error, "Your saved signature could not be deleted"));
+}
+function useSavedSignature(enabled = true) {
+  const { client } = useDocumentTools();
+  return useQuery({
+    queryKey: arbiQueryKeys.savedSignature(),
+    queryFn: () => fetchSavedSignature(client),
+    enabled,
+    staleTime: 6e4,
+    retry: false
+  });
+}
+function useStoreSavedSignature() {
+  const { client } = useDocumentTools();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (signature) => storeSavedSignature(client, signature),
+    onSuccess: (_, signature) => queryClient.setQueryData(arbiQueryKeys.savedSignature(), signature)
+  });
+}
+function useDeleteSavedSignature() {
+  const { client } = useDocumentTools();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () => deleteSavedSignature(client),
+    onSuccess: () => queryClient.setQueryData(arbiQueryKeys.savedSignature(), null)
+  });
+}
+function pngBytes(base64) {
+  const raw = atob(base64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+function pngSize(base64) {
+  const bytes = pngBytes(base64.slice(0, 64));
+  const view = new DataView(bytes.buffer);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function failure(error) {
+  const detail3 = error?.detail;
+  return new Error(typeof detail3 === "string" ? detail3 : "The shared file request failed");
+}
+async function createFileShare(client, documentId, body) {
+  const result = await client.POST("/v1/document/{document_ext_id}/file-shares", {
+    params: { path: { document_ext_id: documentId } },
+    body
+  });
+  if (!result.data) throw failure(result.error);
+  return result.data;
+}
+async function getFileShare(client, id) {
+  const result = await client.GET("/v1/file-shares/{share_id}", {
+    params: { path: { share_id: id } }
+  });
+  if (!result.data) throw failure(result.error);
+  return result.data;
+}
+async function fileShareBytes(client, id, kind) {
+  const result = await client.GET("/v1/file-shares/{share_id}/file", {
+    params: { path: { share_id: id }, query: { kind } },
+    parseAs: "blob"
+  });
+  if (!result.data) throw failure(result.error);
+  return result.data;
+}
+function fileShareSigningRequest(share) {
+  return {
+    external_id: share.external_id,
+    doc_ext_id: share.document_ext_id,
+    version: share.version,
+    source_sha256: share.source_sha256,
+    fields: share.fields,
+    message: share.message,
+    status: share.status === "signing" ? "sent" : share.status === "completed" ? "completed" : "voided",
+    signers: share.recipients.filter((r) => r.permission === "sign").map((r) => ({
+      external_id: r.email,
+      email: r.email,
+      name: r.email,
+      status: r.status === "signed" ? "signed" : "pending",
+      progress: r.status === "signed" ? "signed" : "registered",
+      fields: share.fields.filter((f) => f.signer === r.email).length
+    })),
+    created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+    stale: false
+  };
+}
+async function signFileShare(client, domain, vars) {
+  const path = { share_id: vars.request.external_id };
+  const body = { adopted: vars.adopted, fields: vars.fields };
+  const prepared = await client.POST("/v1/file-shares/{share_id}/sign/prepare", {
+    params: { path },
+    body
+  });
+  if (!prepared.data) throw failure(prepared.error);
+  const { statement, timestamp, source_sha256, intent } = prepared.data;
+  if (source_sha256 !== vars.request.source_sha256 || await sha256Hex(vars.pdfBlob) !== source_sha256)
+    throw new Error("The shared file changed. Ask the sender for a new request.");
+  if (intent !== intentText({ name: vars.adopted.name }))
+    throw new Error("Signing statement mismatch");
+  const identity = await unlockIdentityWithPassword(vars.email, vars.password, domain);
+  const result = await client.POST("/v1/file-shares/{share_id}/sign", {
+    params: { path },
+    body: { ...body, timestamp, signature: signMessage(statement, identity) }
+  });
+  if (!result.data) throw failure(result.error);
+  return {
+    request: fileShareSigningRequest(result.data),
+    completed: result.data.status === "completed"
+  };
+}
+function useFileShare(client, shareId, signing) {
+  return useQuery({
+    queryKey: arbiQueryKeys.fileShare(shareId),
+    queryFn: () => getFileShare(client, shareId),
+    refetchInterval: signing ? false : 5e3
+  });
+}
+function useFileSharePdf(client, shareId, share) {
+  return useQuery({
+    queryKey: arbiQueryKeys.fileSharePdf(shareId, share?.status),
+    queryFn: () => fileShareBytes(client, shareId, share?.status === "completed" ? "signed" : "view"),
+    enabled: !!share?.can_preview,
+    staleTime: Infinity
+  });
+}
+function useFileShares(client) {
+  return useQuery({
+    queryKey: arbiQueryKeys.fileShares(),
+    queryFn: async () => {
+      const result = await client.GET("/v1/file-shares");
+      if (!result.data) throw new Error("Could not load shared files");
+      return result.data;
+    }
+  });
+}
+
+export { DEFAULT_FIELD_SIZE, FIELD_TYPE_LABELS, INFORMAL_SIGNATURE_NOTE, LEGACY_LAYER_PREFIX, MARK_FIELD_TYPES, MAX_MERGE_ATTEMPTS, MarkupStoreError, SIGNATURE_FIELD_TYPES, SIGNED_UNCHANGED, SIGNER_PROGRESS_LABELS, SignatureVerificationError, SigningError, VERIFY_PATH, addToMarkup, canAnnotate, copyOpenThreads, createFileShare, createMarkupStore, deleteSavedSignature, fetchDocumentSignatureRequests, fetchDocumentSignatures, fetchSavedSignature, fetchSignatureVerification, fieldsFromSuggestions, fieldsInSigningOrder, fileShareBytes, fileShareSigningRequest, forgetLegacyLayer, frozenCopyName, getFileShare, initialsOf, intentText, inviteSigners, isEmailSigner, isLegibleSignatureBox, isSignatureReference, marksByVersion, matchSignedCopy, migrateLegacyLayer, newFieldId, openThreadsOf, pngBytes, pngSize, readLegacyLayer, redactionLogName, saveSignatureRequest, sendBlocker, sha256Hex, signDocument, signFileShare, signSignatureRequest, signatureFieldSuggestions, splitSuggestions, storeSavedSignature, suggestSignatureFields, toAppearance, uploadFrozenCopy, useDeclineSignatureRequest, useDeleteSavedSignature, useDocumentBytes, useDocumentMarkup, useDocumentSignatureRequests, useDocumentSignatures, useFileShare, useFileSharePdf, useFileShares, useInviteSigners, useIsOnline, useSaveSignatureRequest, useSavedSignature, useSignDocument, useSignSignatureRequest, useSignatureRequest, useSignatureRequestsAwaitingMe, useSignatureVerification, useSignerCandidates, useStoreSavedSignature, useVoidSignatureRequest, versionsWithMarkup };
+//# sourceMappingURL=chunk-4DTTEUVY.js.map
+//# sourceMappingURL=chunk-4DTTEUVY.js.map