@arbidocs/blocks 0.4.142 → 0.4.143

package/dist/chunk-U6YVZDOV.cjs

@@ -0,0 +1,574 @@
+"use client";
+'use strict';
+
+var chunkJZNXRMLH_cjs = require('./chunk-JZNXRMLH.cjs');
+var chunkGFNELPDP_cjs = require('./chunk-GFNELPDP.cjs');
+var chunk464YPRAE_cjs = require('./chunk-464YPRAE.cjs');
+var chunkV5OAXIBN_cjs = require('./chunk-V5OAXIBN.cjs');
+var chunkLJJJ6CYH_cjs = require('./chunk-LJJJ6CYH.cjs');
+var chunkLPYEUD2D_cjs = require('./chunk-LPYEUD2D.cjs');
+var chunkRQ2Y7USX_cjs = require('./chunk-RQ2Y7USX.cjs');
+var chunkJKB7WT7L_cjs = require('./chunk-JKB7WT7L.cjs');
+var chunkKPZZ5FHE_cjs = require('./chunk-KPZZ5FHE.cjs');
+var chunkKDG6FER6_cjs = require('./chunk-KDG6FER6.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('@arbidocs/react');
+var reactQuery = require('@tanstack/react-query');
+var documentTools = require('@arbidocs/react/document-tools');
+
+var NativeDocxSupportContext = react.createContext({});
+function NativeDocxSupportProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(NativeDocxSupportContext.Provider, { value, children });
+}
+function useNativeDocxSupport() {
+  return react.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 } = chunkJZNXRMLH_cjs.useConnectedDocuments();
+  const { data: tags } = chunkJZNXRMLH_cjs.useConnectedTags();
+  return react.useMemo(() => chunkLPYEUD2D_cjs.buildWorkflowScopeSource(docs, chunkLPYEUD2D_cjs.documentScopeLabels(tags)), [docs, tags]);
+}
+function useConnectedAgentOptions() {
+  const { data: agents } = react$1.useAgents();
+  return react.useMemo(
+    () => (agents ?? []).map((a) => ({ id: a.external_id, label: a.given_name || a.email })),
+    [agents]
+  );
+}
+function ConnectedWorkflowDocumentsField({
+  field,
+  value,
+  onChange,
+  onAddFiles,
+  labels
+}) {
+  const arbi = react$1.useArbi();
+  const { notify } = chunkKPZZ5FHE_cjs.useBlocksEnvironment();
+  const { ensureWorkspaceOpen } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const { data: docs, loaded, refetch } = chunkJZNXRMLH_cjs.useConnectedDocuments();
+  const documents = react.useMemo(() => docs.map(toWorkflowFieldDocument), [docs]);
+  const chosen = value.documents ?? [];
+  const { data: thumbnails } = react$1.useThumbnails(chosen, { enabled: (field.max ?? 1) > 1 });
+  const input = react.useRef(null);
+  const [adding, setAdding] = react.useState(false);
+  const upload = react.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__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    !onAddFiles && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+      chunkLPYEUD2D_cjs.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__ */ jsxRuntime.jsx(
+    chunkLPYEUD2D_cjs.WorkflowLauncher,
+    {
+      ...props,
+      scopeSource,
+      agents,
+      renderDocuments: (field, value, onChange) => /* @__PURE__ */ jsxRuntime.jsx(
+        ConnectedWorkflowDocumentsField,
+        {
+          field,
+          value,
+          onChange,
+          onAddFiles
+        }
+      )
+    }
+  );
+}
+function useConnectedWorkspaceRole() {
+  const { workspaceId, live, userId, ensureWorkspaceOpen } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const { data: members = [] } = react$1.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) => chunkLPYEUD2D_cjs.workflowTriggerType(w).replaceAll("_", " "),
+  formatDate = chunkKDG6FER6_cjs.fmtDate,
+  onViewRuns,
+  connectedLabels,
+  ...tableProps
+}) {
+  const l = { ...DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS, ...connectedLabels };
+  const { notify, confirm, openConversation } = chunkKPZZ5FHE_cjs.useBlocksEnvironment();
+  const { canEditShared, isWorkspaceOwner } = useConnectedWorkspaceRole();
+  const { data: saved = [], isLoading } = react$1.useWorkflows({ live: true });
+  const { data: conversations, refetch } = chunkJZNXRMLH_cjs.useConnectedConversations({ live: true });
+  const { data: agents = [] } = react$1.useAgents();
+  const update = react$1.useUpdateWorkflow();
+  const remove = react$1.useDeleteWorkflow();
+  const run = react$1.useRunWorkflow();
+  const [busyId, setBusyId] = react.useState(null);
+  const workflows = react.useMemo(() => filter ? saved.filter(filter) : saved, [saved, filter]);
+  const firingStamp = saved.map((w) => `${w.external_id}:${w.last_fired_at ?? ""}`).join("|");
+  react.useEffect(() => {
+    void refetch?.();
+  }, [firingStamp, refetch]);
+  const lastRuns = react.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 = react.useMemo(
+    () => Object.fromEntries(agents.map((a) => [a.external_id, a.given_name || a.email])),
+    [agents]
+  );
+  const taskNames = react.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__ */ jsxRuntime.jsx(
+    chunkLPYEUD2D_cjs.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 = react.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__ */ jsxRuntime.jsx(
+    chunkRQ2Y7USX_cjs.DocumentPicker,
+    {
+      groups,
+      value: selectedId ?? "",
+      onValueChange: onSelect,
+      selected,
+      labels: { placeholder: "Search documents\u2026" }
+    }
+  );
+}
+function useConnectedDocxReferences() {
+  const arbi = react$1.useArbi();
+  const { workspaceId } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const { openDocument, runtimeConfig } = chunkKPZZ5FHE_cjs.useBlocksEnvironment();
+  const { data: documents } = chunkJZNXRMLH_cjs.useConnectedDocuments();
+  const documentsRef = react.useRef(documents);
+  documentsRef.current = documents;
+  return react.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 = chunkLJJJ6CYH_cjs.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 } = chunkLJJJ6CYH_cjs.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__ */ jsxRuntime.jsx(
+        ReferencePicker,
+        {
+          documents: documentsRef.current,
+          selectedId,
+          onSelect
+        }
+      )
+    }),
+    [arbi, workspaceId, openDocument, runtimeConfig.deploymentDomain]
+  );
+}
+function useConnectedHouseTemplate() {
+  const arbi = react$1.useArbi();
+  const { mutateAsync: setWorkspaceTemplate } = react$1.useSetWorkspaceHouseTemplate();
+  const { workspaceId, live, ensureWorkspaceOpen } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const { data: workspaces } = react$1.useWorkspaces({ enabled: live });
+  const workspace = workspaces?.find((w) => w.external_id === workspaceId);
+  const { isWorkspaceOwner } = useConnectedWorkspaceRole();
+  const supported = react$1.supportsHouseTemplates(workspace);
+  const templateId = react$1.workspaceHouseTemplateId(workspace);
+  const { data: candidates } = react$1.useHouseTemplateCandidates(
+    workspaceId,
+    supported && isWorkspaceOwner
+  );
+  return react.useMemo(
+    () => ({
+      load: async () => {
+        if (templateId) {
+          await ensureWorkspaceOpen();
+          const response = await arbi.editor.request(chunkV5OAXIBN_cjs.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 chunkV5OAXIBN_cjs.builtinHouseTemplate();
+      },
+      setFromDocument: supported && isWorkspaceOwner ? async (documentId) => {
+        await ensureWorkspaceOpen();
+        await setWorkspaceTemplate(documentId);
+      } : void 0,
+      isEligible: (documentId) => chunk464YPRAE_cjs.isCandidate(candidates, documentId)
+    }),
+    [
+      arbi,
+      setWorkspaceTemplate,
+      supported,
+      templateId,
+      isWorkspaceOwner,
+      candidates,
+      ensureWorkspaceOpen
+    ]
+  );
+}
+function ConnectedNativeDocxEditor({
+  fontBaseUrl = "/native-docx/fonts",
+  ...props
+}) {
+  const adapter = useConnectedNativeDocxAdapter(fontBaseUrl);
+  const { workspaceId } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const { commentTarget } = useNativeDocxSupport();
+  const [openFailed, setOpenFailed] = react.useState(false);
+  const hasOpened = react.useRef(false);
+  const guardedAdapter = react.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;
+  chunkJKB7WT7L_cjs.useRegisterOpenDocument({ documentId: live ? props.documentId : null, workspaceId });
+  const initialCommentId = props.initialCommentId ?? (commentTarget?.documentId === props.documentId ? commentTarget.commentId : void 0);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex h-full min-h-0 flex-col", children: [
+    openFailed && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsxRuntime.jsx(
+      chunkV5OAXIBN_cjs.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 = react$1.useArbi();
+  const { workspaceId, live, user, ensureWorkspaceOpen } = chunkGFNELPDP_cjs.useConnectedWorkspace();
+  const queries = reactQuery.useQueryClient();
+  const { notify } = chunkKPZZ5FHE_cjs.useBlocksEnvironment();
+  const tools = documentTools.useOptionalDocumentTools();
+  const support = useNativeDocxSupport();
+  const references = useConnectedDocxReferences();
+  const houseTemplate = useConnectedHouseTemplate();
+  const { data: members } = react$1.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 = react.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: () => chunk464YPRAE_cjs.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 = react$1.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;
+}
+
+exports.ConnectedNativeDocxEditor = ConnectedNativeDocxEditor;
+exports.ConnectedWorkflowDocumentsField = ConnectedWorkflowDocumentsField;
+exports.ConnectedWorkflowLauncher = ConnectedWorkflowLauncher;
+exports.ConnectedWorkflowsTable = ConnectedWorkflowsTable;
+exports.DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS = DEFAULT_CONNECTED_WORKFLOWS_TABLE_LABELS;
+exports.NativeDocxSupportProvider = NativeDocxSupportProvider;
+exports.toWorkflowFieldDocument = toWorkflowFieldDocument;
+exports.useConnectedAgentOptions = useConnectedAgentOptions;
+exports.useConnectedNativeDocxAdapter = useConnectedNativeDocxAdapter;
+exports.useConnectedWorkflowScopeSource = useConnectedWorkflowScopeSource;
+exports.useConnectedWorkspaceRole = useConnectedWorkspaceRole;
+exports.useNativeDocxSupport = useNativeDocxSupport;
+//# sourceMappingURL=chunk-U6YVZDOV.cjs.map
+//# sourceMappingURL=chunk-U6YVZDOV.cjs.map