@burdenoff/fluidgrids-fe-sdk 2026.1028.2 → 2026.1028.4

package/dist/chunk-JAKWVVVQ.js

@@ -0,0 +1,549 @@
+import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-QGXA2USP.js';
+import { throwIfResultError } from './chunk-5LKZ4PNK.js';
+import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
+import { WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument } from './chunk-JBLYBD2B.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { TagBadge, TagsWidget } from '@burdenoff/fe-libs/tag';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Icon } from '@iconify/react';
+import { Badge, Button } from '@burdenoff/fe-libs/ui';
+
+function toTagItem(assignment) {
+  return {
+    id: assignment.tagId,
+    key: assignment.tagInfo?.key ?? assignment.tagId,
+    label: assignment.tagInfo?.label ?? assignment.tagInfo?.key ?? "Tag",
+    color: assignment.tagInfo?.color ?? null
+  };
+}
+function EntityTagPicker({
+  entityType,
+  entityId,
+  onDraftChange,
+  readOnly = false,
+  onChange,
+  className
+}) {
+  const draftMode = !entityId;
+  const { workspaceId } = getFluidGridsConfig();
+  const { tags: assignments, refetch } = useEntityTags(entityType, entityId);
+  const tagEntity = useTagEntity();
+  const untagEntity = useUntagEntity();
+  const [current, setCurrent] = useState([]);
+  const currentRef = useRef([]);
+  const assignmentKey = assignments.map((a) => a.tagId).join("|");
+  const syncedKey = useRef(null);
+  useEffect(() => {
+    if (draftMode || syncedKey.current === assignmentKey) return;
+    syncedKey.current = assignmentKey;
+    const synced = assignments.map(toTagItem);
+    currentRef.current = synced;
+    setCurrent(synced);
+  }, [assignmentKey, assignments, draftMode]);
+  const handleAdd = useCallback(
+    async (tag) => {
+      if (currentRef.current.some((t) => t.id === tag.id)) return;
+      const next = [...currentRef.current, tag];
+      currentRef.current = next;
+      setCurrent(next);
+      if (draftMode) {
+        onDraftChange?.(next.map((t) => t.id));
+        return;
+      }
+      try {
+        await tagEntity(entityType, entityId, tag.id);
+        await refetch();
+        onChange?.();
+      } catch {
+        const rolledBack = currentRef.current.filter((t) => t.id !== tag.id);
+        currentRef.current = rolledBack;
+        setCurrent(rolledBack);
+      }
+    },
+    [
+      draftMode,
+      entityId,
+      entityType,
+      onChange,
+      onDraftChange,
+      refetch,
+      tagEntity
+    ]
+  );
+  const handleRemove = useCallback(
+    async (tagId) => {
+      const removed = currentRef.current.find((t) => t.id === tagId);
+      const next = currentRef.current.filter((t) => t.id !== tagId);
+      currentRef.current = next;
+      setCurrent(next);
+      if (draftMode) {
+        onDraftChange?.(next.map((t) => t.id));
+        return;
+      }
+      try {
+        await untagEntity(entityType, entityId, tagId);
+        await refetch();
+        onChange?.();
+      } catch {
+        if (removed) {
+          const rolledBack = [...currentRef.current, removed];
+          currentRef.current = rolledBack;
+          setCurrent(rolledBack);
+        }
+      }
+    },
+    [
+      draftMode,
+      entityId,
+      entityType,
+      onChange,
+      onDraftChange,
+      refetch,
+      untagEntity
+    ]
+  );
+  if (readOnly) {
+    if (current.length === 0) return null;
+    return /* @__PURE__ */ jsx("div", { className: `flex flex-wrap items-center gap-1 ${className ?? ""}`, children: current.map((tag) => /* @__PURE__ */ jsx(
+      TagBadge,
+      {
+        id: tag.id,
+        label: tag.label,
+        color: tag.color ?? void 0,
+        size: "sm"
+      },
+      tag.id
+    )) });
+  }
+  return /* @__PURE__ */ jsx(
+    TagsWidget,
+    {
+      entityType,
+      entityId: entityId ?? "",
+      workspaceId: workspaceId || void 0,
+      tags: current,
+      onAdd: handleAdd,
+      onRemove: handleRemove,
+      syncGraphNotifications: !draftMode,
+      className
+    }
+  );
+}
+var PROPOSAL_POLL_INTERVAL_MS = 3e3;
+var PROPOSAL_MAX_WAIT_MS = 6 * 60 * 1e3;
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isProposalRunning(status) {
+  return status === "PROCESSING";
+}
+function useWorkflowProposal() {
+  const [proposal, setProposal] = useState(null);
+  const [isWorking, setIsWorking] = useState(false);
+  const [isDeciding, setIsDeciding] = useState(false);
+  const [error, setError] = useState(null);
+  const [timedOut, setTimedOut] = useState(false);
+  const runRef = useRef(0);
+  const timerRef = useRef(null);
+  const clearTimer = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = null;
+  }, []);
+  useEffect(
+    () => () => {
+      runRef.current++;
+      clearTimer();
+    },
+    [clearTimer]
+  );
+  const reset = useCallback(() => {
+    runRef.current++;
+    clearTimer();
+    setProposal(null);
+    setIsWorking(false);
+    setIsDeciding(false);
+    setError(null);
+    setTimedOut(false);
+  }, [clearTimer]);
+  const poll = useCallback(
+    async (run, id, startedAt) => {
+      if (run !== runRef.current) return;
+      try {
+        const result = throwIfResultError(
+          await getFluidGridsClient().query({
+            query: WorkflowProposalDocument,
+            variables: { id },
+            fetchPolicy: "network-only"
+          })
+        );
+        if (run !== runRef.current) return;
+        const next = result.data?.workflowProposal ?? null;
+        if (next) setProposal(next);
+        const status = next ? String(next.status) : void 0;
+        if (isProposalRunning(status)) {
+          if (Date.now() - startedAt < PROPOSAL_MAX_WAIT_MS) {
+            timerRef.current = setTimeout(
+              () => void poll(run, id, startedAt),
+              PROPOSAL_POLL_INTERVAL_MS
+            );
+            return;
+          }
+          setTimedOut(true);
+        }
+        setIsWorking(false);
+      } catch (pollError) {
+        if (run !== runRef.current) return;
+        setError(messageOf(pollError));
+        setIsWorking(false);
+      }
+    },
+    []
+  );
+  const start = useCallback(
+    async (input) => {
+      const run = ++runRef.current;
+      clearTimer();
+      setProposal(null);
+      setError(null);
+      setTimedOut(false);
+      setIsWorking(true);
+      try {
+        const client = getFluidGridsClient();
+        let started;
+        if (input.kind === "runFix") {
+          const result = throwIfResultError(
+            await client.mutate({
+              mutation: ProposeRunFixDocument,
+              variables: {
+                input: {
+                  runId: input.runId,
+                  ...input.prompt ? { prompt: input.prompt } : {}
+                }
+              }
+            })
+          );
+          started = result.data?.proposeRunFix;
+        } else {
+          const result = throwIfResultError(
+            await client.mutate({
+              mutation: ProposeWorkflowChangeDocument,
+              variables: {
+                input: {
+                  prompt: input.prompt,
+                  ...input.workflowKey ? { workflowKey: input.workflowKey } : {},
+                  ...input.baseVersion ? { baseVersion: input.baseVersion } : {},
+                  ...input.template ? { template: input.template } : {}
+                }
+              }
+            })
+          );
+          started = result.data?.proposeWorkflowChange;
+        }
+        if (!started?.id) throw new Error("The proposal did not start");
+        if (run !== runRef.current) return;
+        setProposal(started);
+        const id = started.id;
+        timerRef.current = setTimeout(
+          () => void poll(run, id, Date.now()),
+          PROPOSAL_POLL_INTERVAL_MS
+        );
+      } catch (startError) {
+        if (run !== runRef.current) return;
+        setError(messageOf(startError));
+        setIsWorking(false);
+      }
+    },
+    [clearTimer, poll]
+  );
+  const decide = useCallback(
+    async (action) => {
+      const id = proposal?.id;
+      if (!id) return null;
+      const run = runRef.current;
+      setIsDeciding(true);
+      setError(null);
+      try {
+        const client = getFluidGridsClient();
+        let next;
+        if (action === "apply") {
+          const result = throwIfResultError(
+            await client.mutate({ mutation: ApplyWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.applyWorkflowProposal;
+        } else if (action === "reject") {
+          const result = throwIfResultError(
+            await client.mutate({ mutation: RejectWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.rejectWorkflowProposal;
+        } else {
+          clearTimer();
+          const result = throwIfResultError(
+            await client.mutate({ mutation: CancelWorkflowProposalDocument, variables: { id } })
+          );
+          next = result.data?.cancelWorkflowProposal;
+          setIsWorking(false);
+        }
+        if (run === runRef.current && next) setProposal(next);
+        return next ?? null;
+      } catch (decideError) {
+        if (run === runRef.current) setError(messageOf(decideError));
+        return null;
+      } finally {
+        if (run === runRef.current) setIsDeciding(false);
+      }
+    },
+    [clearTimer, proposal?.id]
+  );
+  const apply = useCallback(() => decide("apply"), [decide]);
+  const reject = useCallback(async () => {
+    await decide("reject");
+  }, [decide]);
+  const cancel = useCallback(async () => {
+    await decide("cancel");
+  }, [decide]);
+  return {
+    proposal,
+    isWorking,
+    isDeciding,
+    error,
+    timedOut,
+    start,
+    apply,
+    reject,
+    cancel,
+    reset
+  };
+}
+var STATUS_TONE = {
+  PROCESSING: "secondary",
+  PROPOSED: "default",
+  APPLIED: "default",
+  REJECTED: "outline",
+  STALE: "outline",
+  CANCELLED: "outline",
+  FAILED: "destructive"
+};
+function edgeLabel(edge) {
+  const from = edge.sourceHandle ? `${edge.source} (${edge.sourceHandle})` : edge.source;
+  return `${from} \u2192 ${edge.target}`;
+}
+function ChangeList({
+  title,
+  icon,
+  items,
+  testId
+}) {
+  if (items.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { "data-testid": testId, children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 text-xs font-medium uppercase tracking-wide text-text-secondary", children: [
+      /* @__PURE__ */ jsx(Icon, { icon, width: 14 }),
+      title,
+      " (",
+      items.length,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-primary", children: items.map((item) => /* @__PURE__ */ jsx("li", { className: "truncate", children: item }, item)) })
+  ] });
+}
+function nodeLine(node, withFields) {
+  const base = `${node.label} \xB7 ${node.type}`;
+  return withFields && node.fields.length > 0 ? `${base} \u2014 ${node.fields.join(", ")}` : base;
+}
+function WorkflowProposalCard({
+  proposal,
+  isDeciding = false,
+  onOpenWorkflow,
+  onApply,
+  onReject,
+  onCancel,
+  onRevert
+}) {
+  const tr = useTr();
+  const status = String(proposal.status);
+  const diff = proposal.diff;
+  const warnings = proposal.validation?.warnings ?? [];
+  const errors = proposal.validation?.valid === false ? proposal.validation.errors : [];
+  const revertTarget = proposal.baseVersion && proposal.workflowKey && proposal.appliedWorkflowKey === proposal.workflowKey ? { workflowKey: proposal.workflowKey, version: proposal.baseVersion } : null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "workflow-proposal-card",
+      "data-status": status,
+      children: [
+        /* @__PURE__ */ jsxs("header", { className: "flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "mdi:creation-outline",
+              width: 18,
+              className: "text-text-secondary"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-sm font-medium text-text-primary", children: proposal.name ?? tr("fluidgrids.ai.proposal.title", "AI proposal") }),
+          /* @__PURE__ */ jsx(
+            Badge,
+            {
+              variant: STATUS_TONE[status] ?? "outline",
+              "data-testid": "workflow-proposal-status",
+              children: status
+            }
+          ),
+          proposal.baseVersion && /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.ai.proposal.against",
+            "against version {{version}}",
+            {
+              version: proposal.baseVersion
+            }
+          ) })
+        ] }),
+        status === "PROCESSING" && /* @__PURE__ */ jsxs("div", { className: "mt-3 flex items-center gap-2 text-sm text-text-secondary", children: [
+          /* @__PURE__ */ jsx(Icon, { icon: "mdi:loading", width: 16, className: "animate-spin" }),
+          tr("fluidgrids.ai.proposal.working", "Working ({{stage}})\u2026", {
+            stage: proposal.progress?.stage ?? "prompting"
+          }),
+          onCancel && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "ghost",
+              onClick: onCancel,
+              disabled: isDeciding,
+              children: tr("fluidgrids.ai.proposal.cancel", "Cancel")
+            }
+          )
+        ] }),
+        proposal.explanation && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-3 text-sm text-text-primary",
+            "data-testid": "workflow-proposal-explanation",
+            children: proposal.explanation
+          }
+        ),
+        proposal.message && status !== "PROPOSED" && status !== "PROCESSING" && status !== "APPLIED" && /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-text-secondary", children: proposal.message }),
+        diff && /* @__PURE__ */ jsxs("div", { className: "mt-3 space-y-2", "data-testid": "workflow-proposal-diff", children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: diff.summary }),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-added",
+              icon: "mdi:plus-circle-outline",
+              title: tr("fluidgrids.ai.proposal.added", "Added nodes"),
+              items: diff.addedNodes.map((node) => nodeLine(node, false))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-changed",
+              icon: "mdi:pencil-circle-outline",
+              title: tr("fluidgrids.ai.proposal.changed", "Changed nodes"),
+              items: diff.changedNodes.map((node) => nodeLine(node, true))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-removed",
+              icon: "mdi:minus-circle-outline",
+              title: tr("fluidgrids.ai.proposal.removed", "Removed nodes"),
+              items: diff.removedNodes.map((node) => nodeLine(node, false))
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ChangeList,
+            {
+              testId: "workflow-proposal-edges",
+              icon: "mdi:vector-line",
+              title: tr(
+                "fluidgrids.ai.proposal.connections",
+                "Connection changes"
+              ),
+              items: [
+                ...diff.addedEdges.map((edge) => `+ ${edgeLabel(edge)}`),
+                ...diff.removedEdges.map((edge) => `\u2212 ${edgeLabel(edge)}`)
+              ]
+            }
+          )
+        ] }),
+        errors.length > 0 && /* @__PURE__ */ jsx("ul", { className: "mt-3 space-y-1 text-sm text-[var(--color-status-error-text)]", children: errors.map((message) => /* @__PURE__ */ jsx("li", { children: message }, message)) }),
+        warnings.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-3", "data-testid": "workflow-proposal-warnings", children: [
+          /* @__PURE__ */ jsx("div", { className: "text-xs font-medium uppercase tracking-wide text-text-secondary", children: tr("fluidgrids.ai.proposal.todo", "Still to set up") }),
+          /* @__PURE__ */ jsx("ul", { className: "mt-1 space-y-0.5 text-sm text-text-secondary", children: warnings.map((warning) => /* @__PURE__ */ jsx("li", { children: warning }, warning)) })
+        ] }),
+        status === "PROPOSED" && (onApply || onReject) && /* @__PURE__ */ jsxs("div", { className: "mt-4 flex flex-wrap items-center gap-2", children: [
+          onApply && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              onClick: onApply,
+              disabled: isDeciding,
+              "data-testid": "workflow-proposal-apply",
+              children: proposal.baseVersion ? tr(
+                "fluidgrids.ai.proposal.applyVersion",
+                "Apply as a new draft version"
+              ) : tr(
+                "fluidgrids.ai.proposal.applyNew",
+                "Create as a draft workflow"
+              )
+            }
+          ),
+          onReject && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: onReject,
+              disabled: isDeciding,
+              children: tr("fluidgrids.ai.proposal.reject", "Reject")
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.ai.proposal.neverActivates",
+            "Nothing goes live: the result is a draft you can review, run as a test and activate yourself."
+          ) })
+        ] }),
+        status === "APPLIED" && proposal.appliedWorkflowKey && proposal.appliedVersion && /* @__PURE__ */ jsxs("div", { className: "mt-4 space-y-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+            onOpenWorkflow && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                "data-testid": "workflow-proposal-open",
+                onClick: () => onOpenWorkflow(
+                  proposal.appliedWorkflowKey ?? "",
+                  proposal.appliedVersion ?? ""
+                ),
+                children: tr("fluidgrids.ai.proposal.open", "Open draft {{version}}", {
+                  version: proposal.appliedVersion
+                })
+              }
+            ),
+            onRevert && revertTarget && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "ghost",
+                "data-testid": "workflow-proposal-revert",
+                disabled: isDeciding,
+                onClick: () => onRevert(revertTarget.workflowKey, revertTarget.version),
+                children: tr(
+                  "fluidgrids.ai.proposal.revert",
+                  "Revert to {{version}}",
+                  { version: revertTarget.version }
+                )
+              }
+            )
+          ] }),
+          !onRevert && proposal.restoreHint && /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: proposal.restoreHint })
+        ] })
+      ]
+    }
+  );
+}
+
+export { EntityTagPicker, WorkflowProposalCard, useWorkflowProposal };