@burdenoff/fluidgrids-fe-sdk 2026.918.2 → 2026.922.2

package/dist/chunk-I3WUYESA.js

@@ -0,0 +1,668 @@
+import { useTr } from './chunk-7YWBH2A5.js';
+import { nanoid } from 'nanoid/non-secure';
+import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
+import { create } from 'zustand';
+import { produce } from 'immer';
+import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction } from '@burdenoff/fe-libs/ui';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var HISTORY_LIMIT = 100;
+var CLONE_OFFSET = 48;
+function cloneValue(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+var TAGS = [
+  { value: "marketing", label: "Marketing", color: "#ef4444" },
+  { value: "support", label: "Support", color: "#ef4444" },
+  { value: "lead", label: "Lead", color: "#eab308" },
+  { value: "new", label: "New", color: "#22c55e" }
+];
+var INITIAL_EXECUTION = {
+  isExecuting: false,
+  executingNodeId: null,
+  currentRunId: null,
+  logs: [],
+  selectedLogId: null,
+  panelExpanded: false,
+  nodeStatuses: {},
+  nodeItemCounts: {}
+};
+var INITIAL_HISTORY = { past: [], future: [] };
+var useFlowStore = create()((set, get) => {
+  let lastCheckpointKind = null;
+  let lastCheckpointAt = 0;
+  function pushCheckpoint(kind, coalesce) {
+    const now = Date.now();
+    const isCoalesced = coalesce && kind === lastCheckpointKind && now - lastCheckpointAt < 800;
+    if (!isCoalesced) {
+      const state = get();
+      const snapshot = {
+        nodes: cloneValue(state.workflow.nodes),
+        edges: cloneValue(state.workflow.edges)
+      };
+      set((s) => ({
+        history: {
+          past: [...s.history.past, snapshot].slice(-HISTORY_LIMIT),
+          future: []
+        }
+      }));
+    } else if (get().history.future.length > 0) {
+      set((s) => ({ history: { ...s.history, future: [] } }));
+    }
+    lastCheckpointKind = kind;
+    lastCheckpointAt = now;
+  }
+  function resetCoalescing() {
+    lastCheckpointKind = null;
+    lastCheckpointAt = 0;
+  }
+  return {
+    tags: TAGS,
+    history: { ...INITIAL_HISTORY },
+    workflow: {
+      id: nanoid(),
+      workflowKey: "",
+      name: "",
+      version: "",
+      alias: "",
+      edges: [],
+      nodes: [],
+      ndv: null,
+      quickConfig: null,
+      pendingConnection: null,
+      renamingNodeId: null,
+      sidebar: {
+        active: "none",
+        panels: {
+          nodeProperties: {
+            selectedNode: null
+          }
+        }
+      }
+    },
+    execution: { ...INITIAL_EXECUTION },
+    actions: {
+      saveWorkflow: () => {
+        const { workflow } = get();
+        const { id, name, version, alias, dbId, status, nodes, edges } = workflow;
+        set({ workflow });
+        return { id, name, version, alias, dbId, status, nodes, edges };
+      },
+      setWorkflow: (workflow) => {
+        set((state) => ({
+          workflow: {
+            ...state.workflow,
+            ...workflow
+          }
+        }));
+      },
+      resetWorkflow: () => {
+        resetCoalescing();
+        set(() => ({
+          workflow: {
+            id: nanoid(),
+            workflowKey: "",
+            name: "",
+            version: "",
+            alias: "",
+            dbId: void 0,
+            status: void 0,
+            edges: [],
+            nodes: [],
+            ndv: null,
+            quickConfig: null,
+            pendingConnection: null,
+            renamingNodeId: null,
+            sidebar: {
+              active: "none",
+              panels: {
+                nodeProperties: {
+                  selectedNode: null
+                }
+              }
+            }
+          },
+          // Wipe run state too — resetWorkflow fires when the builder loads a
+          // (different) workflow, so the previous workflow's logs must not carry
+          // over into this one's Logs panel.
+          execution: { ...INITIAL_EXECUTION },
+          // A freshly loaded workflow must not be undo-able back to empty —
+          // undo/redo only ever applies within the currently open workflow.
+          history: { ...INITIAL_HISTORY }
+        }));
+      },
+      history: {
+        undo: () => {
+          const { past, future } = get().history;
+          const previous = past[past.length - 1];
+          if (!previous) return;
+          const { nodes, edges } = get().workflow;
+          const current = {
+            nodes: cloneValue(nodes),
+            edges: cloneValue(edges)
+          };
+          resetCoalescing();
+          set((s) => ({
+            workflow: {
+              ...s.workflow,
+              nodes: previous.nodes,
+              edges: previous.edges
+            },
+            history: {
+              past: past.slice(0, -1),
+              future: [current, ...future].slice(0, HISTORY_LIMIT)
+            }
+          }));
+        },
+        redo: () => {
+          const { past, future } = get().history;
+          const next = future[0];
+          if (!next) return;
+          const { nodes, edges } = get().workflow;
+          const current = {
+            nodes: cloneValue(nodes),
+            edges: cloneValue(edges)
+          };
+          resetCoalescing();
+          set((s) => ({
+            workflow: {
+              ...s.workflow,
+              nodes: next.nodes,
+              edges: next.edges
+            },
+            history: {
+              past: [...past, current].slice(-HISTORY_LIMIT),
+              future: future.slice(1)
+            }
+          }));
+        },
+        clear: () => {
+          resetCoalescing();
+          set({ history: { ...INITIAL_HISTORY } });
+        }
+      },
+      ndv: {
+        // Opening the full NDV supersedes the floating quick-config panel — the
+        // two edit the same node data, so only one should be visible at a time.
+        open: (node) => set((state) => ({
+          workflow: { ...state.workflow, ndv: node, quickConfig: null }
+        })),
+        close: () => set((state) => ({
+          workflow: { ...state.workflow, ndv: null }
+        }))
+      },
+      quickConfig: {
+        open: (node) => set((state) => ({
+          workflow: { ...state.workflow, quickConfig: node }
+        })),
+        close: () => set((state) => ({
+          workflow: { ...state.workflow, quickConfig: null }
+        }))
+      },
+      pendingConnection: {
+        start: (connection) => set((state) => ({
+          workflow: {
+            ...state.workflow,
+            pendingConnection: connection,
+            sidebar: { ...state.workflow.sidebar, active: "store-browse" }
+          }
+        })),
+        clear: () => set((state) => ({
+          workflow: { ...state.workflow, pendingConnection: null }
+        }))
+      },
+      sidebar: {
+        // Leaving the store panel abandons any armed "+" attach mode — the
+        // pending handle would otherwise silently capture a later insert.
+        setActivePanel: (panel) => set((state) => ({
+          workflow: {
+            ...state.workflow,
+            sidebar: { ...state.workflow.sidebar, active: panel },
+            ...panel !== "store-browse" ? { pendingConnection: null } : {}
+          }
+        })),
+        showNodePropertiesOf: (node) => {
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              pendingConnection: null,
+              sidebar: {
+                ...state.workflow.sidebar,
+                active: "node-properties",
+                panels: {
+                  ...state.workflow.sidebar.panels,
+                  nodeProperties: {
+                    ...state.workflow.sidebar.panels.nodeProperties,
+                    selectedNode: node
+                  }
+                }
+              }
+            }
+          }));
+        },
+        panels: {
+          nodeProperties: {
+            setSelectedNode: (node) => set((state) => ({
+              workflow: {
+                ...state.workflow,
+                sidebar: {
+                  ...state.workflow.sidebar,
+                  panels: {
+                    ...state.workflow.sidebar.panels,
+                    nodeProperties: {
+                      ...state.workflow.sidebar.panels.nodeProperties,
+                      selectedNode: node
+                    }
+                  }
+                }
+              }
+            }))
+          },
+          tags: {
+            setTags: (tags) => set({ tags }),
+            createTag: (tag) => set((state) => ({
+              tags: [...state.tags, tag]
+            })),
+            updateTag: (tag, newTag) => set((state) => ({
+              tags: state.tags.map(
+                (f) => f.value === tag.value ? newTag : f
+              )
+            })),
+            deleteTag: (tag) => set((state) => ({
+              tags: state.tags.filter((f) => f.value !== tag.value)
+            }))
+          }
+        }
+      },
+      nodes: {
+        onNodesChange: (changes) => {
+          const removedIds = new Set(
+            changes.filter(
+              (c) => c.type === "remove"
+            ).map((c) => c.id)
+          );
+          if (removedIds.size > 0) {
+            const stillPresent = get().workflow.nodes.some(
+              (n) => removedIds.has(n.id)
+            );
+            if (stillPresent) pushCheckpoint("nodes:remove", false);
+          } else {
+            const finishedDragIds = changes.filter(
+              (c) => c.type === "position" && c.dragging === false
+            );
+            const actuallyMoved = finishedDragIds.some((c) => {
+              const current = get().workflow.nodes.find((n) => n.id === c.id);
+              return current && c.position && (current.position.x !== c.position.x || current.position.y !== c.position.y);
+            });
+            if (actuallyMoved) pushCheckpoint("nodes:move", false);
+          }
+          set(
+            (state) => produce(state, (draft) => {
+              const updatedNodes = applyNodeChanges(
+                changes,
+                draft.workflow.nodes
+              );
+              draft.workflow.nodes = updatedNodes;
+            })
+          );
+        },
+        setNodes: (nodes, opts) => {
+          if (!opts?.skipHistory) {
+            pushCheckpoint(
+              opts?.historyKind ?? "nodes:set",
+              !!opts?.historyKind
+            );
+          }
+          set({ workflow: { ...get().workflow, nodes } });
+        },
+        deleteNode: (node) => {
+          const exists = get().workflow.nodes.some((n) => n.id === node.id);
+          if (exists) pushCheckpoint("nodes:delete", false);
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: state.workflow.nodes.filter((n) => n.id !== node.id),
+              // Drop any UI state pointing at the removed node.
+              ...state.workflow.quickConfig?.nodeId === node.id ? { quickConfig: null } : {},
+              ...state.workflow.pendingConnection?.nodeId === node.id ? { pendingConnection: null } : {}
+            }
+          }));
+        },
+        deleteNodes: (nodes) => {
+          const ids = new Set(nodes.map((n) => n.id));
+          if (ids.size === 0) return;
+          const anyExist = get().workflow.nodes.some((n) => ids.has(n.id));
+          if (anyExist) pushCheckpoint("nodes:delete", false);
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: state.workflow.nodes.filter((n) => !ids.has(n.id)),
+              edges: state.workflow.edges.filter(
+                (e) => !ids.has(e.source) && !ids.has(e.target)
+              ),
+              ...state.workflow.quickConfig && ids.has(state.workflow.quickConfig.nodeId) ? { quickConfig: null } : {},
+              ...state.workflow.pendingConnection && ids.has(state.workflow.pendingConnection.nodeId) ? { pendingConnection: null } : {}
+            }
+          }));
+        },
+        duplicateNodes: (nodeIds) => {
+          const { nodes, edges } = get().workflow;
+          const idSet = new Set(nodeIds);
+          const selected = nodes.filter((n) => idSet.has(n.id));
+          if (selected.length === 0) return;
+          pushCheckpoint("nodes:duplicate", false);
+          const idMap = /* @__PURE__ */ new Map();
+          const clones = selected.map((n) => {
+            const newId = nanoid();
+            idMap.set(n.id, newId);
+            const cloned = cloneValue(n);
+            return {
+              ...cloned,
+              id: newId,
+              position: {
+                x: cloned.position.x + CLONE_OFFSET,
+                y: cloned.position.y + CLONE_OFFSET
+              },
+              selected: true
+            };
+          });
+          const clonedEdges = edges.filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((e) => {
+            const cloned = cloneValue(e);
+            return {
+              ...cloned,
+              id: nanoid(),
+              source: idMap.get(e.source),
+              target: idMap.get(e.target),
+              selected: false
+            };
+          });
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: [
+                ...state.workflow.nodes.map(
+                  (n) => idSet.has(n.id) ? { ...n, selected: false } : n
+                ),
+                ...clones
+              ],
+              edges: [...state.workflow.edges, ...clonedEdges]
+            }
+          }));
+        },
+        pasteNodes: (payload) => {
+          const pasteNodesIn = payload.nodes ?? [];
+          if (pasteNodesIn.length === 0) return;
+          pushCheckpoint("nodes:paste", false);
+          const idMap = /* @__PURE__ */ new Map();
+          const clones = pasteNodesIn.map((n) => {
+            const newId = nanoid();
+            idMap.set(n.id, newId);
+            const cloned = cloneValue(n);
+            return {
+              ...cloned,
+              id: newId,
+              position: {
+                x: (cloned.position?.x ?? 0) + CLONE_OFFSET,
+                y: (cloned.position?.y ?? 0) + CLONE_OFFSET
+              },
+              selected: true
+            };
+          });
+          const clonedEdges = (payload.edges ?? []).filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((e) => {
+            const cloned = cloneValue(e);
+            return {
+              ...cloned,
+              id: nanoid(),
+              source: idMap.get(e.source),
+              target: idMap.get(e.target),
+              selected: false
+            };
+          });
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: [
+                ...state.workflow.nodes.map((n) => ({ ...n, selected: false })),
+                ...clones
+              ],
+              edges: [...state.workflow.edges, ...clonedEdges]
+            }
+          }));
+        },
+        toggleDisabled: (nodeId) => {
+          pushCheckpoint("nodes:disable", false);
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: state.workflow.nodes.map((n) => {
+                if (n.id !== nodeId) return n;
+                const data = n.data ?? {};
+                return {
+                  ...n,
+                  data: { ...data, disabled: !(data.disabled === true) }
+                };
+              })
+            }
+          }));
+        },
+        renameNode: (nodeId, label) => {
+          pushCheckpoint("nodes:rename", false);
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              nodes: state.workflow.nodes.map(
+                (n) => n.id === nodeId ? { ...n, data: { ...n.data ?? {}, label } } : n
+              ),
+              renamingNodeId: null
+            }
+          }));
+        },
+        startRename: (nodeId) => {
+          set((state) => ({
+            workflow: { ...state.workflow, renamingNodeId: nodeId }
+          }));
+        },
+        endRename: () => {
+          set((state) => ({
+            workflow: { ...state.workflow, renamingNodeId: null }
+          }));
+        }
+      },
+      edges: {
+        onEdgesChange: (changes) => {
+          const removedIds = new Set(
+            changes.filter(
+              (c) => c.type === "remove"
+            ).map((c) => c.id)
+          );
+          if (removedIds.size > 0) {
+            const stillPresent = get().workflow.edges.some(
+              (e) => removedIds.has(e.id)
+            );
+            if (stillPresent) pushCheckpoint("edges:remove", false);
+          }
+          set(
+            (state) => produce(state, (draft) => {
+              const updatedEdges = applyEdgeChanges(
+                changes,
+                draft.workflow.edges
+              );
+              draft.workflow.edges = updatedEdges;
+            })
+          );
+        },
+        onConnect: (connection) => {
+          pushCheckpoint("edges:connect", false);
+          const edge = {
+            ...connection,
+            id: nanoid(),
+            type: "deletable"
+          };
+          set({
+            workflow: {
+              ...get().workflow,
+              edges: addEdge(edge, get().workflow.edges)
+            }
+          });
+        },
+        setEdges: (edges, opts) => {
+          if (!opts?.skipHistory) {
+            pushCheckpoint(
+              opts?.historyKind ?? "edges:set",
+              !!opts?.historyKind
+            );
+          }
+          set({ workflow: { ...get().workflow, edges } });
+        },
+        deleteEdge: (edge) => {
+          const exists = get().workflow.edges.some((e) => e.id === edge.id);
+          if (exists) pushCheckpoint("edges:delete", false);
+          set((state) => ({
+            workflow: {
+              ...state.workflow,
+              edges: state.workflow.edges.filter((e) => e.id !== edge.id)
+            }
+          }));
+        }
+      },
+      execution: {
+        startExecution: (nodeId, runId) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              isExecuting: true,
+              executingNodeId: nodeId,
+              currentRunId: runId,
+              panelExpanded: true,
+              nodeStatuses: {
+                ...state.execution.nodeStatuses,
+                [nodeId]: "running"
+              }
+            }
+          }));
+        },
+        addLog: (log) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              logs: [...state.execution.logs, log],
+              selectedLogId: log.id
+            }
+          }));
+        },
+        updateLog: (logId, updates) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              logs: state.execution.logs.map(
+                (log) => log.id === logId ? { ...log, ...updates } : log
+              )
+            }
+          }));
+        },
+        setNodeStatus: (nodeId, status) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              nodeStatuses: {
+                ...state.execution.nodeStatuses,
+                [nodeId]: status
+              }
+            }
+          }));
+        },
+        setNodeItemCount: (nodeId, count) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              nodeItemCounts: {
+                ...state.execution.nodeItemCounts,
+                [nodeId]: count
+              }
+            }
+          }));
+        },
+        selectLog: (logId) => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              selectedLogId: logId
+            }
+          }));
+        },
+        togglePanel: () => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              panelExpanded: !state.execution.panelExpanded
+            }
+          }));
+        },
+        clearLogs: () => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              logs: [],
+              selectedLogId: null,
+              nodeStatuses: {},
+              nodeItemCounts: {}
+            }
+          }));
+        },
+        completeExecution: () => {
+          set((state) => ({
+            execution: {
+              ...state.execution,
+              isExecuting: false,
+              executingNodeId: null
+            }
+          }));
+        }
+      }
+    }
+  };
+});
+if (typeof window !== "undefined" && import.meta.env?.DEV) {
+  window.__fgFlowStore = useFlowStore;
+}
+function QuotaExhaustedDialog({
+  open,
+  onOpenChange,
+  onUpgrade,
+  title,
+  description
+}) {
+  const tr = useTr();
+  const resolvedTitle = title ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.title",
+    "Workflow Limit Reached"
+  );
+  const resolvedDescription = description ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.description",
+    "You've reached the workflow limit for your plan. Upgrade your plan to create more workflows."
+  );
+  return /* @__PURE__ */ jsx(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialogContent, { children: [
+    /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+      /* @__PURE__ */ jsx(AlertDialogTitle, { children: resolvedTitle }),
+      /* @__PURE__ */ jsx(AlertDialogDescription, { children: resolvedDescription })
+    ] }),
+    /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+      /* @__PURE__ */ jsx(AlertDialogCancel, { children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.dismiss",
+        "Dismiss"
+      ) }),
+      /* @__PURE__ */ jsx(AlertDialogAction, { onClick: onUpgrade, children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.viewBilling",
+        "View Billing"
+      ) })
+    ] })
+  ] }) });
+}
+
+export { QuotaExhaustedDialog, useFlowStore };
+//# sourceMappingURL=chunk-I3WUYESA.js.map
+//# sourceMappingURL=chunk-I3WUYESA.js.map