@ixo/editor 6.33.0 → 6.35.0

package/dist/XeroInvoiceCreateFlowDetail-UL7KS6CZ.js

@@ -0,0 +1,631 @@
+import {
+  LINE_ITEM_FIELD_KEYS,
+  finaliseLineItem,
+  parseXeroInvoiceCreateInputs
+} from "./chunk-REZ7RFSA.js";
+import {
+  parseXeroPaymentCreateInputs
+} from "./chunk-RWUZOB62.js";
+import {
+  ConnectionSelector
+} from "./chunk-VRZ5LMOW.js";
+import {
+  useXeroWorkItems
+} from "./chunk-TMONHFE3.js";
+import "./chunk-K74XQ4Q5.js";
+import {
+  DataInput
+} from "./chunk-4PONO4US.js";
+import "./chunk-XPBKU3JX.js";
+import {
+  BaseSelect
+} from "./chunk-4NAFQF6V.js";
+import {
+  useRunRuntimeReader
+} from "./chunk-FFYZXA75.js";
+import "./chunk-NZ7AXA7B.js";
+import {
+  buildXeroPaymentWorkKey,
+  getDiffResolver,
+  markXeroWorkCompletedForEditor,
+  markXeroWorkFailedForEditor,
+  updateXeroWorkReviewPayloadForEditor,
+  upsertXeroWorkItemForEditor
+} from "./chunk-F4PTFXZH.js";
+import "./chunk-IH4T7V4C.js";
+import "./chunk-PYNDJDWZ.js";
+import "./chunk-NIXT2SBH.js";
+import "./chunk-JIDTNKKL.js";
+import {
+  parseReferences,
+  resolveReferences,
+  resolveSingleReference
+} from "./chunk-JVROGQ7Q.js";
+import "./chunk-IIIZZ4E4.js";
+import "./chunk-HT6L7A5M.js";
+import "./chunk-N3ORMGAI.js";
+import "./chunk-NCSGIRRQ.js";
+import {
+  DismissibleAlert
+} from "./chunk-IFWKRCFF.js";
+import {
+  actionAlertStyles
+} from "./chunk-6GKJR52N.js";
+import "./chunk-EBFFDDAS.js";
+import {
+  useBlocknoteHandlers
+} from "./chunk-4DGCCXD6.js";
+import "./chunk-7W7UUUIE.js";
+import "./chunk-TS2LNBF2.js";
+
+// src/mantine/blocks/action/actionTypes/xero/invoiceCreate/XeroInvoiceCreateFlowDetail.tsx
+import React, { useCallback as useCallback2, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import { Badge, Box, Button, Group, Stack, Text } from "@mantine/core";
+import { IconX } from "@tabler/icons-react";
+
+// src/core/lib/xeroWorkItemPayloads.ts
+function buildClaimScope(claim, claimData, evaluateBlockId, evaluateContext) {
+  const surveyAnswers = claimData && typeof claimData === "object" ? claimData.credentialSubject ?? claimData.surveyAnswers ?? claimData : {};
+  const evaluationOutput = evaluateContext?.evaluationOutput ?? {};
+  const scope = {
+    claim: {
+      claimId: claim?.claimId || evaluationOutput.claimId || "",
+      agentDid: claim?.agentDid || "",
+      agentAddress: claim?.agentAddress || "",
+      submissionDate: claim?.submissionDate || "",
+      surveyAnswers,
+      ...surveyAnswers
+    },
+    evaluation: {
+      transactionHash: evaluationOutput.transactionHash || "",
+      amount: evaluationOutput.amount || "",
+      date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+    }
+  };
+  const trimmedId = String(evaluateBlockId || "").trim();
+  if (trimmedId) {
+    scope[trimmedId] = {
+      output: {
+        claimId: claim?.claimId || evaluationOutput.claimId || "",
+        collectionId: evaluateContext?.collectionId || "",
+        deedDid: evaluateContext?.deedDid || "",
+        surveyAnswers,
+        ...evaluationOutput
+      }
+    };
+  }
+  return scope;
+}
+async function resolvePaymentWorkPayload(block, editorDocument, baseScope, settlement) {
+  const parsed = parseXeroPaymentCreateInputs(block?.props?.inputs);
+  const scope = {
+    ...baseScope,
+    invoice: { invoiceId: settlement.invoiceId, InvoiceID: settlement.invoiceId },
+    evaluation: {
+      transactionHash: settlement.transactionHash,
+      amount: settlement.amount,
+      date: settlement.date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+    }
+  };
+  const opts = { scope };
+  const resolveStr = (v) => resolveReferences(v || "", editorDocument, opts);
+  const currencyRateRaw = resolveStr(parsed.CurrencyRate);
+  const currencyRate = currencyRateRaw ? Number(currencyRateRaw) : void 0;
+  const amountRaw = resolveStr(parsed.Amount);
+  const amount = Number.isFinite(Number(amountRaw)) && Number(amountRaw) > 0 ? Number(amountRaw) : settlement.amount;
+  const payload = {
+    tenant_id: resolveStr(parsed.tenant_id),
+    InvoiceID: resolveStr(parsed.InvoiceID) || settlement.invoiceId,
+    Date: resolveStr(parsed.Date) || settlement.date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    Amount: amount,
+    Reference: resolveStr(parsed.Reference) || settlement.transactionHash,
+    CurrencyRate: typeof currencyRate === "number" && Number.isFinite(currencyRate) ? currencyRate : void 0
+  };
+  let preview = [];
+  const resolver = getDiffResolver("qi/xero.payment.create");
+  if (resolver) {
+    try {
+      preview = await resolver.resolver({ ...payload, Amount: String(payload.Amount) }, {});
+    } catch {
+      preview = [];
+    }
+  }
+  return { payload, preview };
+}
+function getInvoiceTotal(output) {
+  const total = typeof output.total === "number" ? output.total : Number(output.total);
+  return Number.isFinite(total) && total > 0 ? total : 0;
+}
+
+// src/mantine/blocks/action/actionTypes/xero/_shared/useFlowXeroConnection.ts
+import { useCallback, useEffect, useState } from "react";
+var CONNECTION_KEY = "connection";
+function useFlowXeroConnection(editor) {
+  const connectionMap = editor?._yXeroConnection || null;
+  const [connection, setConnection] = useState(() => connectionMap?.get(CONNECTION_KEY) || null);
+  useEffect(() => {
+    if (!connectionMap?.observe) return;
+    const sync = () => setConnection(connectionMap.get(CONNECTION_KEY) || null);
+    connectionMap.observe(sync);
+    sync();
+    return () => connectionMap.unobserve(sync);
+  }, [connectionMap]);
+  const saveConnection = useCallback(
+    (next) => {
+      if (!connectionMap) return;
+      if (next) {
+        connectionMap.set(CONNECTION_KEY, next);
+      } else {
+        connectionMap.delete(CONNECTION_KEY);
+      }
+    },
+    [connectionMap]
+  );
+  return [connection, saveConnection];
+}
+
+// src/mantine/blocks/action/actionTypes/xero/invoiceCreate/XeroInvoiceCreateFlowDetail.tsx
+function shortId(value, length = 10) {
+  const text = String(value || "");
+  return text.length > length ? text.slice(0, length) : text;
+}
+function getLineTotal(lineItems) {
+  if (!Array.isArray(lineItems)) return 0;
+  return lineItems.reduce((sum, item) => {
+    const qty = Number(item?.Quantity) || 0;
+    const unitAmount = Number(item?.UnitAmount) || 0;
+    return sum + qty * unitAmount;
+  }, 0);
+}
+function formatAmount(total, currency) {
+  const code = String(currency || "").trim();
+  const amount = Number.isFinite(total) ? total.toFixed(2) : "0.00";
+  return code ? `${amount} ${code}` : amount;
+}
+function lineItemToCells(item) {
+  return {
+    Description: String(item?.Description || ""),
+    Quantity: String(item?.Quantity ?? "1"),
+    UnitAmount: String(item?.UnitAmount ?? ""),
+    AccountCode: String(item?.AccountCode || ""),
+    TaxType: String(item?.TaxType || ""),
+    ItemCode: String(item?.ItemCode || ""),
+    DiscountRate: String(item?.DiscountRate ?? "")
+  };
+}
+function payloadLineItemsToCells(lineItems) {
+  if (!Array.isArray(lineItems)) return [];
+  return lineItems.map((item) => lineItemToCells(item && typeof item === "object" ? item : null));
+}
+function resolveIterativeSource(source, editorDocument, opts) {
+  const refs = parseReferences(source || "");
+  if (refs.length === 0) return [];
+  const ref = refs[0];
+  const value = resolveSingleReference(ref.blockId, ref.propPath, editorDocument, opts.yRuntime, opts.scope);
+  return Array.isArray(value) ? value : [];
+}
+function resolveCells(cells, editorDocument, opts) {
+  const out = {};
+  for (const key of LINE_ITEM_FIELD_KEYS) {
+    out[key] = resolveReferences(cells[key] || "", editorDocument, opts);
+  }
+  return out;
+}
+function buildLineItemsArray(config, editorDocument, opts) {
+  if (config.mode === "manual") {
+    if (config.rows.length === 0) {
+      throw new Error("At least one line item is required.");
+    }
+    return config.rows.map((row) => finaliseLineItem(resolveCells(row, editorDocument, opts)));
+  }
+  const elements = resolveIterativeSource(config.source, editorDocument, opts);
+  if (elements.length === 0) {
+    throw new Error("The bound source list is empty or could not be resolved.");
+  }
+  return elements.map((element) => {
+    const perItemOpts = { ...opts, scope: { ...opts.scope || {}, item: element } };
+    return finaliseLineItem(resolveCells(config.map, editorDocument, perItemOpts));
+  });
+}
+var XeroInvoiceCreateFlowDetail = ({
+  inputs,
+  editor,
+  block,
+  runtime,
+  isDisabled,
+  provideSigningHandler,
+  unlockSigning,
+  registerRuntimeInputs,
+  executeAction
+}) => {
+  const handlers = useBlocknoteHandlers();
+  const flowId = useMemo(() => editor?.getFlowMetadata?.()?.doc_id || block.id, [editor, block.id]);
+  const actorDid = useMemo(() => {
+    try {
+      return handlers?.getCurrentUser?.()?.address || "";
+    } catch {
+      return "";
+    }
+  }, [handlers]);
+  const entityDid = useMemo(() => handlers?.getEntityDid?.() || "", [handlers]);
+  const parsed = useMemo(() => parseXeroInvoiceCreateInputs(inputs), [inputs]);
+  const editorDocument = editor?.document || [];
+  const runtimeReader = useRunRuntimeReader(editor);
+  const resolveOpts = useMemo(() => ({ yRuntime: runtimeReader }), [runtimeReader]);
+  const seedFromTemplate = useCallback2(
+    (field) => {
+      const v = parsed[field];
+      if (typeof v !== "string") return "";
+      const doc = editor?.document || [];
+      return resolveReferences(v, doc, resolveOpts);
+    },
+    [parsed, editor, resolveOpts]
+  );
+  const [local, setLocal] = useState2(() => ({
+    Status: seedFromTemplate("Status"),
+    ContactID: seedFromTemplate("ContactID"),
+    ContactName: seedFromTemplate("ContactName"),
+    Date: seedFromTemplate("Date"),
+    DueDate: seedFromTemplate("DueDate"),
+    InvoiceNumber: seedFromTemplate("InvoiceNumber"),
+    Reference: seedFromTemplate("Reference"),
+    CurrencyCode: seedFromTemplate("CurrencyCode")
+  }));
+  const [reviewLineItems, setReviewLineItems] = useState2([]);
+  useEffect2(() => {
+    setLocal((prev) => {
+      const next = {
+        Status: prev.Status || seedFromTemplate("Status"),
+        ContactID: prev.ContactID || seedFromTemplate("ContactID"),
+        ContactName: prev.ContactName || seedFromTemplate("ContactName"),
+        Date: prev.Date || seedFromTemplate("Date"),
+        DueDate: prev.DueDate || seedFromTemplate("DueDate"),
+        InvoiceNumber: prev.InvoiceNumber || seedFromTemplate("InvoiceNumber"),
+        Reference: prev.Reference || seedFromTemplate("Reference"),
+        CurrencyCode: prev.CurrencyCode || seedFromTemplate("CurrencyCode")
+      };
+      if (next.Status === prev.Status && next.ContactID === prev.ContactID && next.ContactName === prev.ContactName && next.Date === prev.Date && next.DueDate === prev.DueDate && next.InvoiceNumber === prev.InvoiceNumber && next.Reference === prev.Reference && next.CurrencyCode === prev.CurrencyCode) {
+        return prev;
+      }
+      return next;
+    });
+  }, [parsed]);
+  const update = useCallback2((patch) => {
+    setLocal((prev) => ({ ...prev, ...patch }));
+  }, []);
+  const workItems = useXeroWorkItems(editor, { kind: "invoice.create", assignedBlockId: block.id, statuses: ["pending", "failed", "completed"] });
+  const [selectedWorkItemId, setSelectedWorkItemId] = useState2("");
+  const selectedWorkItem = useMemo(() => workItems.find((item) => item.id === selectedWorkItemId) || null, [workItems, selectedWorkItemId]);
+  const selectedWorkItemCompleted = selectedWorkItem?.status === "completed";
+  useEffect2(() => {
+    if (!selectedWorkItem) return;
+    const payload = selectedWorkItem.reviewPayload || {};
+    setSelectedWorkItemId(selectedWorkItem.id);
+    setLocal({
+      Status: String(payload.Status || "DRAFT"),
+      ContactID: String(payload.ContactID || ""),
+      ContactName: String(payload.ContactName || ""),
+      Date: String(payload.Date || ""),
+      DueDate: String(payload.DueDate || ""),
+      InvoiceNumber: String(payload.InvoiceNumber || ""),
+      Reference: String(payload.Reference || ""),
+      CurrencyCode: String(payload.CurrencyCode || "")
+    });
+    setReviewLineItems(payloadLineItemsToCells(payload.LineItems));
+  }, [selectedWorkItem?.id]);
+  const connection = parsed.connection;
+  const [flowConnection, setFlowConnection] = useFlowXeroConnection(editor);
+  const effectiveConnection = selectedWorkItem?.reviewPayload?.connection || connection || flowConnection;
+  const hasConnection = !!effectiveConnection?.connectedAccountId;
+  const entityMismatch = hasConnection && entityDid && effectiveConnection.entityDid && effectiveConnection.entityDid !== entityDid;
+  const isCompleted = runtime.state === "completed" && !selectedWorkItem;
+  const paymentBlock = useMemo(() => {
+    if (!selectedWorkItem) return null;
+    const evaluationBlock = editor?.document?.find((candidate) => candidate?.id === selectedWorkItem.source.evaluationBlockId);
+    const inputs2 = typeof evaluationBlock?.props?.inputs === "string" ? JSON.parse(evaluationBlock.props.inputs || "{}") : evaluationBlock?.props?.inputs || {};
+    const paymentBlockId = String(inputs2?.xeroPaymentBlockId || "").trim();
+    return paymentBlockId ? editor?.document?.find((candidate) => candidate?.id === paymentBlockId && candidate?.props?.actionType === "qi/xero.payment.create") || null : null;
+  }, [editor, selectedWorkItem]);
+  const lineItemsValidation = useMemo(() => {
+    try {
+      if (selectedWorkItem) {
+        const arr2 = reviewLineItems.map((item) => finaliseLineItem(item));
+        return { ok: arr2.length > 0, count: arr2.length };
+      }
+      const doc = editor?.document || [];
+      const arr = buildLineItemsArray(parsed.LineItems, doc, resolveOpts);
+      return { ok: arr.length > 0, count: arr.length };
+    } catch (err) {
+      return { ok: false, count: 0, error: err instanceof Error ? err.message : "Line items are invalid." };
+    }
+  }, [parsed.LineItems, editor, resolveOpts, reviewLineItems, selectedWorkItem]);
+  const hasContact = !!(local.ContactID.trim() || local.ContactName.trim());
+  const requiresAuthorised = !!selectedWorkItem && !!paymentBlock;
+  const statusValid = !requiresAuthorised || local.Status.toUpperCase() === "AUTHORISED";
+  const readyToSign = hasConnection && !entityMismatch && lineItemsValidation.ok && hasContact && statusValid && !isCompleted && !selectedWorkItemCompleted;
+  const canShowDetail = (selectedWorkItemCompleted || hasConnection && !entityMismatch) && !isCompleted && (workItems.length === 0 || selectedWorkItem);
+  useEffect2(() => {
+    unlockSigning?.(readyToSign);
+  }, [unlockSigning, readyToSign]);
+  useEffect2(() => {
+    registerRuntimeInputs?.({
+      ...local,
+      __xeroHasQueuedWork: workItems.length > 0,
+      __xeroSelectedWorkItemId: selectedWorkItem && !selectedWorkItemCompleted ? selectedWorkItem.id : ""
+    });
+  }, [registerRuntimeInputs, local, selectedWorkItem?.id, selectedWorkItemCompleted, workItems.length]);
+  const [error, setError] = useState2(null);
+  const execute = useCallback2(async () => {
+    if (selectedWorkItemCompleted) {
+      return;
+    }
+    if (!hasConnection) {
+      setError("Connect Xero before running this action.");
+      return;
+    }
+    const editorDoc = editor?.document || [];
+    let lineItems;
+    try {
+      lineItems = selectedWorkItem ? reviewLineItems.map((item) => finaliseLineItem(item)) : buildLineItemsArray(parsed.LineItems, editorDoc, resolveOpts);
+      if (!Array.isArray(lineItems) || lineItems.length === 0) throw new Error("At least one line item is required.");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Line items are invalid.");
+      return;
+    }
+    if (requiresAuthorised && local.Status.toUpperCase() !== "AUTHORISED") {
+      setError("This invoice must be authorised before it can create payment work.");
+      return;
+    }
+    const submittedPayload = {
+      ...selectedWorkItem?.reviewPayload || {},
+      connection: effectiveConnection,
+      Status: local.Status || (selectedWorkItem ? selectedWorkItem.reviewPayload.Status : void 0),
+      Date: local.Date,
+      DueDate: local.DueDate,
+      ContactID: local.ContactID,
+      ContactName: local.ContactName,
+      Reference: local.Reference,
+      InvoiceNumber: local.InvoiceNumber,
+      CurrencyCode: local.CurrencyCode,
+      LineItems: lineItems
+    };
+    if (selectedWorkItem) updateXeroWorkReviewPayloadForEditor(editor, selectedWorkItem.id, submittedPayload);
+    setError(null);
+    try {
+      if (!executeAction) {
+        throw new Error("Shared action executor is unavailable");
+      }
+      const outcome = await executeAction({
+        runtimeInputs: submittedPayload
+      });
+      if (!outcome.success) {
+        throw new Error(outcome.error || "Xero invoice creation failed");
+      }
+      const output = outcome.output || {};
+      if (selectedWorkItem) {
+        const completed = markXeroWorkCompletedForEditor(editor, selectedWorkItem.id, { byDid: actorDid, payload: submittedPayload, result: output });
+        if (completed && paymentBlock && String(output.status || "").toUpperCase() === "AUTHORISED" && String(output.invoiceId || "")) {
+          const baseScope = buildClaimScope(completed.provenance.claimSnapshot, completed.provenance.evaluationOutput?.surveyAnswers || {}, completed.source.evaluationBlockId, {
+            deedDid: completed.source.deedDid,
+            collectionId: completed.source.collectionId,
+            evaluationOutput: completed.provenance.evaluationOutput
+          });
+          const { payload } = await resolvePaymentWorkPayload(paymentBlock, editorDoc, baseScope, {
+            invoiceId: String(output.invoiceId),
+            transactionHash: String(completed.provenance.evaluationOutput?.transactionHash || ""),
+            amount: getInvoiceTotal(output)
+          });
+          const idempotencyKey = buildXeroPaymentWorkKey({
+            flowId,
+            evaluationBlockId: completed.source.evaluationBlockId,
+            claimId: completed.source.claimId,
+            invoiceWorkItemId: completed.id
+          });
+          upsertXeroWorkItemForEditor(editor, {
+            id: idempotencyKey,
+            kind: "payment.create",
+            status: "pending",
+            assignedBlockId: paymentBlock.id,
+            idempotencyKey,
+            source: { ...completed.source, invoiceWorkItemId: completed.id },
+            originalPayload: payload,
+            reviewPayload: payload,
+            provenance: {
+              createdAt: Date.now(),
+              createdByDid: actorDid,
+              templateBlockId: paymentBlock.id,
+              templateInputsSnapshot: paymentBlock.props?.inputs,
+              evaluationOutput: completed.provenance.evaluationOutput,
+              claimSnapshot: completed.provenance.claimSnapshot
+            },
+            attempts: []
+          });
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to create Xero invoice";
+      setError(message);
+      if (selectedWorkItem) markXeroWorkFailedForEditor(editor, selectedWorkItem.id, { byDid: actorDid, payload: submittedPayload, error: message });
+    }
+  }, [
+    actorDid,
+    effectiveConnection,
+    editor,
+    executeAction,
+    flowId,
+    hasConnection,
+    local,
+    parsed.LineItems,
+    resolveOpts,
+    reviewLineItems,
+    selectedWorkItemCompleted,
+    selectedWorkItem,
+    paymentBlock,
+    requiresAuthorised
+  ]);
+  useEffect2(() => {
+    if (!provideSigningHandler) return;
+    provideSigningHandler(execute);
+  }, [provideSigningHandler, execute]);
+  return /* @__PURE__ */ React.createElement(Stack, { gap: "md" }, !hasConnection && !selectedWorkItemCompleted && /* @__PURE__ */ React.createElement(ConnectionSelector, { toolkit: "xero", toolkitLabel: "Xero", value: flowConnection, onChange: setFlowConnection }), entityMismatch && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, "This block was configured for a different workspace. Reconnect Xero to use it here."), workItems.length > 0 && /* @__PURE__ */ React.createElement(Stack, { gap: "sm" }, /* @__PURE__ */ React.createElement(Group, { justify: "space-between", align: "center" }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600 }, "Invoices"), /* @__PURE__ */ React.createElement(Badge, { variant: "light", color: "gray" }, workItems.length)), workItems.map((item) => /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      key: item.id,
+      style: {
+        border: selectedWorkItem?.id === item.id ? "1px solid var(--mantine-color-teal-5)" : "1px solid var(--mantine-color-neutralColor-6)",
+        borderRadius: 6,
+        padding: 12,
+        background: selectedWorkItem?.id === item.id ? "rgba(42, 234, 179, 0.08)" : "var(--mantine-color-neutralColor-5)"
+      }
+    },
+    /* @__PURE__ */ React.createElement(Group, { justify: "space-between", align: "flex-start", gap: "md", wrap: "nowrap" }, /* @__PURE__ */ React.createElement(Stack, { gap: 4, style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement(Group, { gap: "xs", wrap: "wrap" }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600 }, String(item.reviewPayload?.InvoiceNumber || item.reviewPayload?.Reference || item.reviewPayload?.ContactName || "Invoice work")), /* @__PURE__ */ React.createElement(Badge, { size: "xs", color: item.status === "completed" ? "green" : item.status === "failed" ? "red" : "blue", variant: "light" }, item.status), /* @__PURE__ */ React.createElement(Badge, { size: "xs", color: "gray", variant: "outline" }, String(item.reviewPayload?.Type || "ACCREC"))), /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed", truncate: true }, "Claim ", shortId(item.source.claimId), " \xB7 Contact ", String(item.reviewPayload?.ContactName || item.reviewPayload?.ContactID || "missing")), /* @__PURE__ */ React.createElement(Group, { gap: "md", wrap: "wrap" }, /* @__PURE__ */ React.createElement(Text, { size: "xs" }, "Total ", formatAmount(getLineTotal(item.reviewPayload?.LineItems), item.reviewPayload?.CurrencyCode)), item.reviewPayload?.DueDate && /* @__PURE__ */ React.createElement(Text, { size: "xs" }, "Due ", String(item.reviewPayload.DueDate)), /* @__PURE__ */ React.createElement(Text, { size: "xs" }, Array.isArray(item.reviewPayload?.LineItems) ? item.reviewPayload.LineItems.length : 0, " line item(s)"))), /* @__PURE__ */ React.createElement(
+      Button,
+      {
+        size: "xs",
+        variant: selectedWorkItem?.id === item.id ? "filled" : "light",
+        leftSection: selectedWorkItem?.id === item.id ? /* @__PURE__ */ React.createElement(IconX, { size: 14 }) : void 0,
+        onClick: () => setSelectedWorkItemId(selectedWorkItem?.id === item.id ? "" : item.id)
+      },
+      selectedWorkItem?.id === item.id ? "Close" : item.status === "completed" ? "Open" : "Review"
+    ))
+  ))), canShowDetail && /* @__PURE__ */ React.createElement(Stack, { gap: "sm" }, selectedWorkItem && /* @__PURE__ */ React.createElement(Group, { justify: "space-between", align: "center" }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600 }, selectedWorkItemCompleted ? "Completed invoice" : "Reviewing queued invoice"), /* @__PURE__ */ React.createElement(Button, { size: "xs", variant: "subtle", leftSection: /* @__PURE__ */ React.createElement(IconX, { size: 14 }), onClick: () => setSelectedWorkItemId("") }, "Close review")), selectedWorkItem && /* @__PURE__ */ React.createElement(
+    BaseSelect,
+    {
+      label: "Status",
+      data: [
+        { value: "DRAFT", label: "Draft" },
+        { value: "SUBMITTED", label: "Submitted" },
+        { value: "AUTHORISED", label: "Authorised" }
+      ],
+      value: local.Status || "DRAFT",
+      onChange: (value) => update({ Status: value || "DRAFT" }),
+      disabled: selectedWorkItemCompleted
+    }
+  ), /* @__PURE__ */ React.createElement(
+    DataInput,
+    {
+      label: "Contact ID",
+      value: local.ContactID,
+      onChange: (value) => update({ ContactID: value }),
+      editorDocument,
+      currentBlockId: block.id,
+      disabled: selectedWorkItemCompleted
+    }
+  ), /* @__PURE__ */ React.createElement(
+    DataInput,
+    {
+      label: "Contact name (if no ID)",
+      value: local.ContactName,
+      onChange: (value) => update({ ContactName: value }),
+      editorDocument,
+      currentBlockId: block.id,
+      disabled: selectedWorkItemCompleted
+    }
+  ), /* @__PURE__ */ React.createElement(
+    DataInput,
+    {
+      label: "Due date",
+      value: local.DueDate,
+      onChange: (value) => update({ DueDate: value }),
+      editorDocument,
+      currentBlockId: block.id,
+      disabled: selectedWorkItemCompleted
+    }
+  ), selectedWorkItem && /* @__PURE__ */ React.createElement(
+    DataInput,
+    {
+      label: "Currency",
+      value: local.CurrencyCode,
+      onChange: (value) => update({ CurrencyCode: value }),
+      editorDocument,
+      currentBlockId: block.id,
+      disabled: selectedWorkItemCompleted
+    }
+  ), selectedWorkItem && /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(Group, { justify: "space-between", align: "center" }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 600 }, "Line items"), /* @__PURE__ */ React.createElement(Badge, { color: lineItemsValidation.ok ? "green" : "yellow", variant: "light" }, lineItemsValidation.count)), reviewLineItems.map((item, index) => /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      key: index,
+      style: {
+        border: "1px solid var(--mantine-color-neutralColor-5)",
+        borderRadius: 6,
+        padding: 12,
+        background: "var(--mantine-color-neutralColor-2)"
+      }
+    },
+    /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed", fw: 600 }, "Line item ", index + 1), /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Description",
+        value: item.Description,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, Description: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    ), /* @__PURE__ */ React.createElement(Group, { grow: true }, /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Quantity",
+        value: item.Quantity,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, Quantity: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    ), /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Unit amount",
+        value: item.UnitAmount,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, UnitAmount: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    ), /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Account code",
+        value: item.AccountCode,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, AccountCode: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    )), /* @__PURE__ */ React.createElement(Group, { grow: true }, /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Tax type",
+        value: item.TaxType,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, TaxType: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    ), /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Item code",
+        value: item.ItemCode,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, ItemCode: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    ), /* @__PURE__ */ React.createElement(
+      DataInput,
+      {
+        label: "Discount %",
+        value: item.DiscountRate,
+        onChange: (value) => setReviewLineItems((prev) => prev.map((line, lineIndex) => lineIndex === index ? { ...line, DiscountRate: value } : line)),
+        editorDocument,
+        currentBlockId: block.id,
+        disabled: selectedWorkItemCompleted
+      }
+    )))
+  ))), !selectedWorkItemCompleted && !lineItemsValidation.ok && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, lineItemsValidation.error || "Line items require attention \u2014 edit in template mode."), !selectedWorkItemCompleted && !statusValid && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "yellow", styles: actionAlertStyles }, "A payment block is bound, so this invoice work item must be authorised before execution.")), isCompleted && workItems.length === 0 && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "green", styles: actionAlertStyles }, "Invoice created", runtime.output?.invoiceNumber ? ` \u2014 ${runtime.output.invoiceNumber}` : "", "."), error && /* @__PURE__ */ React.createElement(DismissibleAlert, { color: "red", styles: actionAlertStyles }, error), isDisabled && !isCompleted && /* @__PURE__ */ React.createElement(Text, { size: "xs", c: "dimmed" }, "This block is currently disabled."));
+};
+export {
+  XeroInvoiceCreateFlowDetail
+};
+//# sourceMappingURL=XeroInvoiceCreateFlowDetail-UL7KS6CZ.js.map