@arbidocs/blocks 0.4.142 → 0.4.143

package/dist/chunk-FJETR2AS.js

@@ -0,0 +1,561 @@
+"use client";
+import { useConnectedDocuments, useConnectedTags, useConnectedConversations } from './chunk-45LRMW54.js';
+import { useConnectedWorkspace } from './chunk-US3S4DCB.js';
+import { loadDocxFonts, isCandidate } from './chunk-MTSKK3BN.js';
+import { NativeDocxEditor, contentPath, builtinHouseTemplate } from './chunk-2FL7QJKJ.js';
+import { parseDeepLinkPath, buildDeepLinkUrl } from './chunk-SV65E4QW.js';
+import { buildWorkflowScopeSource, documentScopeLabels, WorkflowDocumentsField, WorkflowLauncher, WorkflowsTable, workflowTriggerType } from './chunk-T5B7FM7S.js';
+import { DocumentPicker } from './chunk-KSHKTOY2.js';
+import { useRegisterOpenDocument } from './chunk-YBLIKTJK.js';
+import { useBlocksEnvironment } from './chunk-TBEVGWY3.js';
+import { fmtDate } from './chunk-OXF2IFXG.js';
+import { createContext, useContext, useMemo, useRef, useState, useCallback, useEffect } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useAgents, useArbi, useThumbnails, useWorkspaceUsers, useWorkflows, useUpdateWorkflow, useDeleteWorkflow, useRunWorkflow, arbiQueryKeys, useSetWorkspaceHouseTemplate, useWorkspaces, supportsHouseTemplates, workspaceHouseTemplateId, useHouseTemplateCandidates } from '@arbidocs/react';
+import { useQueryClient } from '@tanstack/react-query';
+import { useOptionalDocumentTools } from '@arbidocs/react/document-tools';
+
+var NativeDocxSupportContext = createContext({});
+function NativeDocxSupportProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsx(NativeDocxSupportContext.Provider, { value, children });
+}
+function useNativeDocxSupport() {
+  return useContext(NativeDocxSupportContext);
+}
+var IMAGE_FILE_TYPES = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "bmp", "tiff", "webp"]);
+function toWorkflowFieldDocument(doc) {
+  const isImage = IMAGE_FILE_TYPES.has((doc.file_type ?? "").toLowerCase());
+  return {
+    id: doc.external_id,
+    title: doc.doc_metadata?.title || doc.file_name || doc.external_id,
+    fileName: doc.file_name,
+    pages: isImage ? null : doc.n_pages ?? null,
+    tokens: isImage ? null : doc.tokens ?? null,
+    status: doc.status,
+    isImage
+  };
+}
+function useConnectedWorkflowScopeSource() {
+  const { data: docs } = useConnectedDocuments();
+  const { data: tags } = useConnectedTags();
+  return useMemo(() => buildWorkflowScopeSource(docs, documentScopeLabels(tags)), [docs, tags]);
+}
+function useConnectedAgentOptions() {
+  const { data: agents } = useAgents();
+  return useMemo(
+    () => (agents ?? []).map((a) => ({ id: a.external_id, label: a.given_name || a.email })),
+    [agents]
+  );
+}
+function ConnectedWorkflowDocumentsField({
+  field,
+  value,
+  onChange,
+  onAddFiles,
+  labels
+}) {
+  const arbi = useArbi();
+  const { notify } = useBlocksEnvironment();
+  const { ensureWorkspaceOpen } = useConnectedWorkspace();
+  const { data: docs, loaded, refetch } = useConnectedDocuments();
+  const documents = useMemo(() => docs.map(toWorkflowFieldDocument), [docs]);
+  const chosen = value.documents ?? [];
+  const { data: thumbnails } = useThumbnails(chosen, { enabled: (field.max ?? 1) > 1 });
+  const input = useRef(null);
+  const [adding, setAdding] = useState(false);
+  const upload = useCallback(
+    async (files) => {
+      setAdding(true);
+      try {
+        await ensureWorkspaceOpen();
+        for (const file of files) await arbi.documents.uploadFile(file, file.name);
+      } catch (error) {
+        notify(error instanceof Error && error.message ? error.message : String(error), "error");
+      } finally {
+        setAdding(false);
+        await refetch?.();
+      }
+    },
+    [arbi, ensureWorkspaceOpen, notify, refetch]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    !onAddFiles && /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: input,
+        type: "file",
+        multiple: true,
+        className: "hidden",
+        "aria-label": "Add files",
+        "data-testid": "workflow-add-files-input",
+        onChange: (e) => {
+          const files = Array.from(e.target.files ?? []);
+          e.target.value = "";
+          if (files.length) void upload(files);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      WorkflowDocumentsField,
+      {
+        field,
+        value,
+        onChange,
+        documents,
+        loaded,
+        thumbnailOf: (id) => thumbnails?.[id],
+        onAddFiles: onAddFiles ?? ((files) => files?.length ? void upload(files) : input.current?.click()),
+        adding,
+        labels
+      }
+    )
+  ] });
+}
+function ConnectedWorkflowLauncher({
+  onAddFiles,
+  ...props
+}) {
+  const scopeSource = useConnectedWorkflowScopeSource();
+  const agents = useConnectedAgentOptions();
+  return /* @__PURE__ */ jsx(
+    WorkflowLauncher,
+    {
+      ...props,
+      scopeSource,
+      agents,
+      renderDocuments: (field, value, onChange) => /* @__PURE__ */ jsx(
+        ConnectedWorkflowDocumentsField,
+        {
+          field,
+          value,
+          onChange,
+          onAddFiles
+        }
+      )
+    }
+  );
+}
+function useConnectedWorkspaceRole() {
+  const { workspaceId, live, userId, ensureWorkspaceOpen } = useConnectedWorkspace();
+  const { data: members = [] } = useWorkspaceUsers(workspaceId ?? void 0, {
+    enabled: live && !!workspaceId,
+    beforeFetch: ensureWorkspaceOpen
+  });
+  const role = members.find((m) => m.user.external_id === userId)?.role;
+  return {
+    members,
+    role,
+    /** An owner or a collaborator edits, pauses, resumes and runs what is shared with the workspace. */
+    canEditShared: role === "owner" || role === "collaborator",
+    /** With an item's creator, the only one who deletes it. */
+    isWorkspaceOwner: role === "owner"
+  };
+}
+var DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS = {
+  updateFailed: "Could not update the workflow",
+  deleteTitle: "Delete workflow",
+  deleteOne: (name) => `Delete \u201C${name}\u201D? Threads it already created stay.`,
+  deleteMany: (count) => `Delete ${count} workflows? Threads they already created stay.`,
+  runFailed: "The workflow failed. You can send an error report from its history.",
+  noThread: "The workflow did not create a thread.",
+  documentAction: (workflow) => workflow.action?.type === "email_documents" ? "Preparing your document email" : "Reviewing documents",
+  untitledTask: "Untitled thread"
+};
+var messageOf = (error) => error instanceof Error ? error.message : "";
+function ConnectedWorkflowsTable({
+  filter,
+  describeTrigger = (w) => workflowTriggerType(w).replaceAll("_", " "),
+  formatDate = fmtDate,
+  onViewRuns,
+  connectedLabels,
+  ...tableProps
+}) {
+  const l = { ...DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS, ...connectedLabels };
+  const { notify, confirm, openConversation } = useBlocksEnvironment();
+  const { canEditShared, isWorkspaceOwner } = useConnectedWorkspaceRole();
+  const { data: saved = [], isLoading } = useWorkflows({ live: true });
+  const { data: conversations, refetch } = useConnectedConversations({ live: true });
+  const { data: agents = [] } = useAgents();
+  const update = useUpdateWorkflow();
+  const remove = useDeleteWorkflow();
+  const run = useRunWorkflow();
+  const [busyId, setBusyId] = useState(null);
+  const workflows = useMemo(() => filter ? saved.filter(filter) : saved, [saved, filter]);
+  const firingStamp = saved.map((w) => `${w.external_id}:${w.last_fired_at ?? ""}`).join("|");
+  useEffect(() => {
+    void refetch?.();
+  }, [firingStamp, refetch]);
+  const lastRuns = useMemo(() => {
+    const out = {};
+    for (const c of conversations) {
+      const id = c.workflow_ext_id;
+      if (id && (!out[id] || Date.parse(c.created_at) > Date.parse(out[id].at)))
+        out[id] = { conversationId: c.external_id, at: c.created_at, threadStatus: c.status };
+    }
+    return out;
+  }, [conversations]);
+  const agentNames = useMemo(
+    () => Object.fromEntries(agents.map((a) => [a.external_id, a.given_name || a.email])),
+    [agents]
+  );
+  const taskNames = useMemo(
+    () => Object.fromEntries(
+      conversations.filter((c) => c.status != null).map((c) => [c.external_id, c.title || l.untitledTask])
+    ),
+    [conversations, l.untitledTask]
+  );
+  const act = async (workflow, action) => {
+    setBusyId(workflow.external_id);
+    try {
+      await action();
+    } catch (error) {
+      notify(messageOf(error) || l.updateFailed, "error");
+    } finally {
+      setBusyId(null);
+    }
+  };
+  const setActive = (workflow, active) => act(workflow, () => update.mutateAsync({ workflowId: workflow.external_id, patch: { active } }));
+  const deleteAll = async (items) => {
+    if (!items.length) return;
+    const ok = await confirm({
+      title: l.deleteTitle,
+      message: items.length === 1 ? l.deleteOne(items[0].name) : l.deleteMany(items.length)
+    });
+    if (!ok) return;
+    for (const workflow of items)
+      await act(workflow, () => remove.mutateAsync(workflow.external_id));
+  };
+  return /* @__PURE__ */ jsx(
+    WorkflowsTable,
+    {
+      ...tableProps,
+      workflows,
+      isLoading,
+      busyId,
+      describeTrigger,
+      formatDate,
+      agentNames,
+      taskNames,
+      lastRuns,
+      canEditShared,
+      isWorkspaceOwner,
+      onOpenThread: (conversationId) => openConversation(conversationId),
+      onViewRuns,
+      onToggleActive: (workflow, active) => void setActive(workflow, active),
+      onToggleActiveMany: (items, active) => {
+        void (async () => {
+          for (const workflow of items) await setActive(workflow, active);
+        })();
+      },
+      onToggleShared: (workflow, shared) => void act(
+        workflow,
+        () => update.mutateAsync({ workflowId: workflow.external_id, patch: { shared } })
+      ),
+      onDelete: (workflow) => void deleteAll([workflow]),
+      onDeleteMany: (items) => void deleteAll(items),
+      onRun: (workflow) => void act(workflow, async () => {
+        const result = await run.mutateAsync(workflow.external_id);
+        if (result.conversation_ext_id) openConversation(result.conversation_ext_id);
+        if (result.error) {
+          onViewRuns?.(workflow);
+          notify(l.runFailed, "error");
+          return;
+        }
+        if (result.execution_id && !result.conversation_ext_id) {
+          onViewRuns?.(workflow);
+          notify(l.documentAction(workflow), "success");
+          return;
+        }
+        if (!result.conversation_ext_id) throw new Error(l.noThread);
+      })
+    }
+  );
+}
+var isTopLevel = (doc) => !doc.parent_ext_id;
+function ReferencePicker({
+  documents,
+  selectedId,
+  onSelect
+}) {
+  const groups = useMemo(() => {
+    const docs = documents.filter(isTopLevel).map(toWorkflowFieldDocument).sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()));
+    return [{ id: "all", heading: "In this workspace", docs }];
+  }, [documents]);
+  const selected = groups[0].docs.find((d) => d.id === selectedId);
+  return /* @__PURE__ */ jsx(
+    DocumentPicker,
+    {
+      groups,
+      value: selectedId ?? "",
+      onValueChange: onSelect,
+      selected,
+      labels: { placeholder: "Search documents\u2026" }
+    }
+  );
+}
+function useConnectedDocxReferences() {
+  const arbi = useArbi();
+  const { workspaceId } = useConnectedWorkspace();
+  const { openDocument, runtimeConfig } = useBlocksEnvironment();
+  const { data: documents } = useConnectedDocuments();
+  const documentsRef = useRef(documents);
+  documentsRef.current = documents;
+  return useMemo(
+    () => ({
+      documents: async () => documentsRef.current.filter(isTopLevel).map((d) => ({ id: d.external_id, title: toWorkflowFieldDocument(d).title })),
+      passages: async (documentId) => {
+        const parsed = await arbi.documents.getParsedContent(documentId, "final");
+        return (parsed.chunks ?? []).flatMap(
+          (chunk) => chunk.metadata?.chunk_ext_id && chunk.content?.trim() ? [
+            {
+              chunkId: chunk.metadata.chunk_ext_id,
+              page: chunk.metadata.page_number ?? null,
+              text: chunk.content
+            }
+          ] : []
+        );
+      },
+      linkFor: ({ documentId, chunkId, page }) => {
+        const url = buildDeepLinkUrl(
+          { workspaceId: workspaceId ?? void 0, documentId, chunkId },
+          runtimeConfig.deploymentDomain
+        );
+        return page ? `${url}?page=${page}` : url;
+      },
+      targetOf: (href) => {
+        let url;
+        try {
+          url = new URL(href, window.location.origin);
+        } catch {
+          return null;
+        }
+        const { documentId, chunkId } = parseDeepLinkPath(url.pathname);
+        if (!documentId || !chunkId) return null;
+        const page = Number(url.searchParams.get("page")) || null;
+        return { documentId, chunkId, page };
+      },
+      open: ({ documentId, chunkId, page }) => openDocument(documentId, { passageId: chunkId, page: page ?? void 0 }),
+      renderDocumentPicker: (onSelect, selectedId) => /* @__PURE__ */ jsx(
+        ReferencePicker,
+        {
+          documents: documentsRef.current,
+          selectedId,
+          onSelect
+        }
+      )
+    }),
+    [arbi, workspaceId, openDocument, runtimeConfig.deploymentDomain]
+  );
+}
+function useConnectedHouseTemplate() {
+  const arbi = useArbi();
+  const { mutateAsync: setWorkspaceTemplate } = useSetWorkspaceHouseTemplate();
+  const { workspaceId, live, ensureWorkspaceOpen } = useConnectedWorkspace();
+  const { data: workspaces } = useWorkspaces({ enabled: live });
+  const workspace = workspaces?.find((w) => w.external_id === workspaceId);
+  const { isWorkspaceOwner } = useConnectedWorkspaceRole();
+  const supported = supportsHouseTemplates(workspace);
+  const templateId = workspaceHouseTemplateId(workspace);
+  const { data: candidates } = useHouseTemplateCandidates(
+    workspaceId,
+    supported && isWorkspaceOwner
+  );
+  return useMemo(
+    () => ({
+      load: async () => {
+        if (templateId) {
+          await ensureWorkspaceOpen();
+          const response = await arbi.editor.request(contentPath(templateId));
+          const [record] = await arbi.documents.get([templateId]).catch(() => []);
+          return {
+            bytes: new Uint8Array(await response.arrayBuffer()),
+            name: record?.file_name ?? "House template.docx",
+            source: "workspace",
+            documentId: templateId
+          };
+        }
+        if (supported) {
+          const deployment = await arbi.houseTemplates.deployment();
+          if (deployment) return { ...deployment, source: "deployment" };
+        }
+        return builtinHouseTemplate();
+      },
+      setFromDocument: supported && isWorkspaceOwner ? async (documentId) => {
+        await ensureWorkspaceOpen();
+        await setWorkspaceTemplate(documentId);
+      } : void 0,
+      isEligible: (documentId) => isCandidate(candidates, documentId)
+    }),
+    [
+      arbi,
+      setWorkspaceTemplate,
+      supported,
+      templateId,
+      isWorkspaceOwner,
+      candidates,
+      ensureWorkspaceOpen
+    ]
+  );
+}
+function ConnectedNativeDocxEditor({
+  fontBaseUrl = "/native-docx/fonts",
+  ...props
+}) {
+  const adapter = useConnectedNativeDocxAdapter(fontBaseUrl);
+  const { workspaceId } = useConnectedWorkspace();
+  const { commentTarget } = useNativeDocxSupport();
+  const [openFailed, setOpenFailed] = useState(false);
+  const hasOpened = useRef(false);
+  const guardedAdapter = useMemo(
+    () => ({
+      ...adapter,
+      open: async (documentId) => {
+        try {
+          const session = await adapter.open(documentId);
+          hasOpened.current = true;
+          return session;
+        } catch (error) {
+          if (!hasOpened.current) setOpenFailed(true);
+          throw error;
+        }
+      }
+    }),
+    [adapter]
+  );
+  const live = !props.snapshot && !props.stream && !props.draftContent && !props.compact;
+  useRegisterOpenDocument({ documentId: live ? props.documentId : null, workspaceId });
+  const initialCommentId = props.initialCommentId ?? (commentTarget?.documentId === props.documentId ? commentTarget.commentId : void 0);
+  return /* @__PURE__ */ jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [
+    openFailed && /* @__PURE__ */ jsx("p", { role: "status", className: "text-muted-foreground border-b px-3 py-2 text-xs", children: "Co-editing isn't available for this document right now, so this is a read-only copy of the last saved version." }),
+    /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx(
+      NativeDocxEditor,
+      {
+        ...props,
+        snapshot: props.snapshot || openFailed,
+        initialCommentId,
+        adapter: guardedAdapter
+      }
+    ) })
+  ] });
+}
+function tokenChanges(arbi) {
+  return (listener) => {
+    if (!arbi.isLoggedIn) return () => {
+    };
+    const session = arbi.getClient().session;
+    let token = session.getState().accessToken;
+    return session.subscribe((state) => {
+      if (state.accessToken === token) return;
+      token = state.accessToken;
+      listener();
+    });
+  };
+}
+function useConnectedNativeDocxAdapter(fontBaseUrl = "/native-docx/fonts") {
+  const arbi = useArbi();
+  const { workspaceId, live, user, ensureWorkspaceOpen } = useConnectedWorkspace();
+  const queries = useQueryClient();
+  const { notify } = useBlocksEnvironment();
+  const tools = useOptionalDocumentTools();
+  const support = useNativeDocxSupport();
+  const references = useConnectedDocxReferences();
+  const houseTemplate = useConnectedHouseTemplate();
+  const { data: members } = useWorkspaceUsers(workspaceId ?? void 0, {
+    enabled: live && !!workspaceId,
+    beforeFetch: ensureWorkspaceOpen
+  });
+  const onDocumentsChanged = tools?.onDocumentsChanged;
+  const author = live && arbi.user.profile()?.givenName || user?.name || "You";
+  const adapter = useMemo(
+    () => ({
+      request: async (path, options) => {
+        await ensureWorkspaceOpen();
+        return arbi.editor.request(path, options);
+      },
+      open: async (id) => {
+        await ensureWorkspaceOpen();
+        return (await arbi.editor.request(`/${encodeURIComponent(id)}/session`, { method: "POST" })).json();
+      },
+      save: async (id, state) => (await arbi.editor.request(`/${encodeURIComponent(id)}/save`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ state })
+      })).json(),
+      loadFonts: () => loadDocxFonts(fontBaseUrl),
+      baseUrl: arbi.getConnectionInfo()?.baseUrl || window.location.origin,
+      author,
+      subscribeTokenChanges: tokenChanges(arbi),
+      onDirtyChange: support.onDirtyChange,
+      onVersionSaved: async (id) => {
+        const hostRefresh = onDocumentsChanged?.([id], "version");
+        if (workspaceId) {
+          const key = arbiQueryKeys.documents(workspaceId);
+          try {
+            const documents = await arbi.documents.get([id]);
+            if (!documents.length) throw new Error("The saved version is not available yet.");
+            queries.setQueryData(
+              key,
+              (previous) => [
+                ...documents,
+                ...(previous || []).filter(
+                  (doc) => !documents.some((saved) => saved.external_id === doc.external_id)
+                )
+              ]
+            );
+          } catch {
+            await queries.invalidateQueries({ queryKey: key });
+          }
+        }
+        await hostRefresh;
+      },
+      notify,
+      mentions: members?.map(({ user: member }) => ({
+        id: member.external_id,
+        name: [member.given_name, member.family_name].filter(Boolean).join(" "),
+        kind: member.external_id.startsWith("agt-") ? "agent" : "human"
+      })),
+      requestAgent: async (id, request) => {
+        const response = await arbi.editor.request(`/${encodeURIComponent(id)}/mentions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            comment_id: request.commentId,
+            instruction: request.instruction,
+            request_id: request.requestId,
+            recipient_ids: request.recipientIds
+          })
+        });
+        const delivery = await response.json();
+        notify("Mention delivered.", "success");
+        return { responseIds: delivery.response_ids || [] };
+      },
+      getAgentStatus: async (responseId) => (await arbi.assistant.getResponse(responseId)).status,
+      definitions: support.definitions,
+      references,
+      imageGeneration: support.imageGeneration,
+      houseTemplate
+    }),
+    [
+      arbi,
+      author,
+      members,
+      ensureWorkspaceOpen,
+      fontBaseUrl,
+      queries,
+      workspaceId,
+      notify,
+      onDocumentsChanged,
+      support,
+      references,
+      houseTemplate
+    ]
+  );
+  return adapter;
+}
+
+export { ConnectedNativeDocxEditor, ConnectedWorkflowDocumentsField, ConnectedWorkflowLauncher, ConnectedWorkflowsTable, DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS, NativeDocxSupportProvider, toWorkflowFieldDocument, useConnectedAgentOptions, useConnectedNativeDocxAdapter, useConnectedWorkflowScopeSource, useConnectedWorkspaceRole, useNativeDocxSupport };
+//# sourceMappingURL=chunk-FJETR2AS.js.map
+//# sourceMappingURL=chunk-FJETR2AS.js.map