@arbidocs/blocks 0.4.147 → 0.4.150

package/dist/connection/tags/TagsPageSections.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The two views of the Tags page's main area: every tag of a kind as a table (`KindSection`), and
+ * one tag in full (`TagSection`) — its placement and actions, its sub-tags as rows, its fields
+ * editable in place, and every document (with the tag's note there and the passages it cites),
+ * fact and thread tagged with it.
+ */
+import type { ReactNode } from 'react';
+import { type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+import { type TagTableFilter } from './ConnectedTagTable';
+/** What both views share: the filter and where a tagged item opens. */
+export interface TagsPageViewContext {
+    filter: TagTableFilter;
+    onOpenTag: (tagId: string) => void;
+    onOpenFact?: (factId: string) => void;
+}
+/** Every tag of a kind as a table, under the kind's heading (the picker at its right). */
+export declare function KindSection({ kind, ctx, extractingCount, picker, }: {
+    kind: TagKind;
+    ctx: TagsPageViewContext;
+    extractingCount: number;
+    picker: ReactNode;
+}): import("react").JSX.Element;
+/** One tag in full: its placement and actions, its sub-tags, and everything tagged with it. */
+export declare function TagSection({ tag, tags, ctx, actions, onEdit, onDelete, onBack, renderPassages, picker, }: {
+    tag: TagResponse;
+    tags: readonly TagResponse[];
+    ctx: TagsPageViewContext;
+    /** Its own actions before Edit (e.g. printing the glossary of the Definitions label). */
+    actions?: ReactNode;
+    /** Edit it. Absent: no Edit. */
+    onEdit?: () => void;
+    onDelete: () => void;
+    onBack: () => void;
+    renderPassages: (docId: string, label: string) => ReactNode;
+    picker: ReactNode;
+}): import("react").JSX.Element;

package/dist/connection/tags/tagCombine.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The Tags page's filter: a tri-state choice per tag (include / exclude, as the Files filter), one
+ * state for the whole page whichever kind is open, and what it lets through across the workspace —
+ * documents, facts and threads. Matching is the tri-state filter's own evaluator
+ * (`applyInvertedIndexFilter`): include is OR across tags, exclude drops a match and wins over
+ * include. Every view then shows only the tagged items that pass (`narrowTagRow`,
+ * `narrowTagTable`), and only the tags with some left.
+ */
+import { type TagNode, type TagResponse } from '@arbidocs/sdk/browser';
+import type { TriState } from '../../settings/TriStateFilterMenu';
+import type { TagTableData, TagTableRow } from '../../tags/tagTableModel';
+export type TagCombination = Map<string, TriState>;
+/** Whether any tag is included or excluded. */
+export declare const isCombining: (combination: TagCombination) => boolean;
+/**
+ * The next combination after the user changes it: a tag newly included or excluded brings its
+ * sub-tags along (each can then be unset on its own); a tag set back to neither takes along the
+ * sub-tags that still carry the state it had.
+ */
+export declare function cascadeTagCombination(tags: readonly TagNode[], previous: TagCombination, next: TagCombination): TagCombination;
+/** What the filter lets through: the ids of the documents, facts and threads that pass. */
+export interface TagFilterMatches {
+    docs: Set<string>;
+    facts: Set<string>;
+    threads: Set<string>;
+}
+/** The workspace's tagged items the filter reads: each item's id and the tags it carries. */
+export interface TaggedItems {
+    documents: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+    facts: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+    threads: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+}
+/**
+ * What the filter lets through (undefined: no filter). Every list is the workspace's own, so an
+ * exclusion applies to everything, not only to what an included tag links.
+ */
+export declare function tagCombinationMatches(combination: TagCombination, items: TaggedItems): TagFilterMatches | undefined;
+/**
+ * Narrow one tag's tagged items to what the filter lets through (`matches`; absent: no filter),
+ * counting what is left; `shown` keeps that many of each list (a table cell lists a few).
+ */
+export declare function narrowTagRow(row: TagTableRow, matches: TagFilterMatches | undefined, shown?: number): TagTableRow;
+/** A table under the filter: each row narrowed, and only the rows with tagged items left. */
+export declare function narrowTagTable(table: TagTableData | undefined, matches: TagFilterMatches | undefined, shown?: number): TagTableData | undefined;
+/** A tag's values as text a filter can match (a linked tag by its name). */
+export declare function tagValueText(tag: Pick<TagResponse, 'field_values'>, nameOf: (id: string) => string | undefined): string;

package/dist/connection/useConnectedWorkNotifications.d.ts

@@ -1,27 +1,10 @@
-import type { components } from '@arbidocs/client';
-export type WorkNotificationTarget = {
-    kind: 'conversation';
-    workspaceId: string;
-    conversationId: string;
-    messageId?: string;
-} | {
-    kind: 'workflow';
-    workspaceId?: string;
-    workflowId: string;
-}
-/** A draft an agent left for the user (`mail_draft_ready`): open it, e.g. `ConnectedMailbox draftId`. */
- | {
-    kind: 'mail_draft';
-    draftId: string;
-    mailbox?: string;
-};
-/** Persisted work notifications in the shared bell; the consumer owns navigation. */
-export declare function useConnectedWorkNotifications(onOpen: (target: WorkNotificationTarget) => void | Promise<void>): {
+import { type NotificationTarget } from '@arbidocs/react';
+/**
+ * Persisted work notifications (mentions, finished and failed runs, access requests, drafts an
+ * agent left) in the shared bell. What each says and where it leads is the one shared mapping,
+ * `describeServerNotification`; the consumer turns a {@link NotificationTarget} into its routes.
+ */
+export declare function useConnectedWorkNotifications(onOpen: (target: NotificationTarget) => void | Promise<void>): {
     onMarkRead: (id: string) => void;
     onMarkAllRead: () => void;
 };
-/** Route from explicit IDs; encrypted task text is never needed for a link. */
-export declare function mapWorkNotification(note: components['schemas']['NotificationResponse']): {
-    title: string;
-    target: WorkNotificationTarget;
-} | null;

package/dist/connection/viewer/ConnectedDocumentToolsProvider.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The PDF document tools (markup, Freeze, signing, signature requests, productions) on the
+ * signed-in session, for any host: the API client, the signed-in user, the host's notices and
+ * document opening (`BlocksEnvironment`), and the shared caches a change refreshes. A host with its
+ * own binding (its own lists to refresh, an XHR upload with progress, Mail) keeps it: an enclosing
+ * `DocumentToolsProvider` wins.
+ */
+import { type ReactNode } from 'react';
+export declare function ConnectedDocumentToolsProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/connection/viewer/ConnectedDocumentViewer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The whole document viewer on the signed-in session: a document (or one of its versions, read
+ * only) as its PDF, its text, the Word editor, a sheet, an image, a recording or a live artifact;
+ * its versions and comparisons; markup, signing and signature requests; sharing, Email, Translate
+ * and Finalise. Runs under any host (`useConnectedWorkspace`): the open document, tab and comparison
+ * are the session state's, navigation the `BlocksEnvironment`'s, and what only the host knows comes
+ * through `DocumentViewerSupportProvider`.
+ */
+import { type ReactNode } from 'react';
+export interface ConnectedDocumentViewerProps {
+    /**
+     * The document, or a version reference `doc-…@v{n}` (a citation, a "made from v2" link): an
+     * earlier version opens read-only. Default: the session state's viewing document.
+     */
+    documentId?: string;
+    /** Controls at the right end of the header (a panel's dock / pop-out switcher). */
+    headerActions?: ReactNode;
+    /** Where html/react artifacts load their sandbox runtime from. */
+    artifactRuntimeUrl?: string;
+}
+export declare function ConnectedDocumentViewer(props: ConnectedDocumentViewerProps): import("react").JSX.Element | null;

package/dist/connection/viewer/FinaliseTranslationButton.d.ts

@@ -0,0 +1,15 @@
+interface TranslationDocument {
+    external_id: string;
+    derived_from?: ReadonlyArray<{
+        role?: string | null;
+    }> | null;
+}
+/**
+ * Finalise: save the translation's current version as a new PDF document, labelled "Translation" and
+ * linked to the original. The editable translation stays as it is; the new PDF opens.
+ */
+export declare function FinaliseTranslationButton({ document, isCompact, }: {
+    document: TranslationDocument | undefined;
+    isCompact: boolean;
+}): React.ReactElement | null;
+export {};

package/dist/connection/viewer/ViewerPdfPane.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The PDF (or media) body of the document viewer: loading and failure states, the image, audio and
+ * video players, and the PDF with its tools — the markup layer, signature placement, a signature
+ * request being prepared or signed.
+ */
+import type { SignatureAppearance, SignatureRequest, useDocumentMarkup } from '@arbidocs/react/document-tools';
+import { type PdfViewerProps } from '@arbidocs/react/viewers';
+import { type ViewedDocument } from './useViewedDocument';
+/** A signature request: the author placing fields, or a signer walked through theirs. */
+export type SignatureFlow = {
+    kind: 'prepare';
+    draft?: SignatureRequest;
+} | {
+    kind: 'sign';
+    request: SignatureRequest;
+} | null;
+/**
+ * The kit PDF viewer, reporting the page read into the session state; in a detached window its
+ * pages render without the opener's web fonts (canvas text in another document cannot use them).
+ */
+export declare function SessionPdfViewer(props: Omit<PdfViewerProps, 'onPageChange' | 'disableFontFace'>): import("react").JSX.Element;
+export interface ViewerPdfPaneProps {
+    documentId: string;
+    doc: ViewedDocument;
+    pdfBlob: Blob | null;
+    isPdfLoading: boolean;
+    pdfError: unknown;
+    onDownload: () => void;
+    viewerProps: {
+        currentPage: number | undefined;
+        onLoadSuccess: (pages: number) => void;
+        scrollTrigger: number;
+        zoom: number;
+        onZoomChange: (zoom: number) => void;
+    };
+    signatureFlow: SignatureFlow;
+    onSignatureFlow: (flow: SignatureFlow) => void;
+    currentUserId: string | undefined;
+    placingSignature: boolean;
+    onPlacingDone: (appearance?: SignatureAppearance) => void;
+    annotating: boolean;
+    markup: ReturnType<typeof useDocumentMarkup>;
+    pdfSnapshotNumber: number | undefined;
+    isSigned: boolean;
+}
+export declare function ViewerPdfPane({ documentId, doc, pdfBlob, isPdfLoading, pdfError, onDownload, viewerProps, signatureFlow, onSignatureFlow, currentUserId, placingSignature, onPlacingDone, annotating, markup, pdfSnapshotNumber, isSigned, }: ViewerPdfPaneProps): import("react").JSX.Element;

package/dist/connection/viewer/support.d.ts

@@ -0,0 +1,79 @@
+/**
+ * What a host adds to the connected document viewer. The viewer reads documents, versions, PDFs,
+ * markup and signatures on the signed-in session by itself; these are the host's own things it
+ * cannot know: documents the host makes on the client (an artifact streaming in from a chat, an
+ * unsaved draft), the host's dialogs and workflows a document action opens, and how the host lays
+ * the viewer out. Every field is optional: without one the viewer offers less (no Translate button,
+ * no draft controls), never something that does nothing.
+ */
+import { type ReactNode } from 'react';
+import type { components } from '@arbidocs/client';
+/** A document's record, as the viewer reads it. */
+export type ViewerDocumentRecord = components['schemas']['DocResponse'];
+/** An artifact being generated in a chat, shown in the viewer as it streams. */
+export interface ViewerStreamingDocument {
+    title?: string | null;
+    /** The content so far (Markdown, or the html/react source of a live artifact). */
+    content: string;
+    /** How it is carried: a document draft, a live `html` / `react` artifact, an `image`. */
+    mode?: string | null;
+    isComplete: boolean;
+}
+/** A document the user started on the client, with no backend record until it is saved. */
+export interface ViewerDraftDocument {
+    kind: 'text' | 'audio' | 'photo' | 'video';
+    title?: string | null;
+    /** A text draft's starting content. */
+    content?: string | null;
+}
+export interface DocumentViewerSupport {
+    /** Artifacts streaming in, by document id. */
+    streamingDocuments?: Readonly<Record<string, ViewerStreamingDocument>>;
+    /** Unsaved drafts, by their client id. */
+    draftDocuments?: Readonly<Record<string, ViewerDraftDocument>>;
+    /** A draft's kind (text, photo, audio, video), in place of the tabs. */
+    renderDraftKind?: (draftId: string) => ReactNode;
+    /** A draft's name (editable), in place of the title. */
+    renderDraftTitle?: (draftId: string) => ReactNode;
+    /** The recorder of a photo, audio or video draft: the whole body of the viewer. */
+    renderCaptureDraft?: (draftId: string) => ReactNode;
+    /** A text draft was saved as `documentId`; the viewer shows it next. */
+    onDraftSaved?: (draftId: string, documentId: string) => void;
+    /** The copy of a document kept on this device, for when the network is down. */
+    loadOfflineCopy?: (document: ViewerDocumentRecord) => Promise<Blob | undefined>;
+    /** Documents related to the one open (near duplicates), beside its name. */
+    renderRelated?: (document: ViewerDocumentRecord) => ReactNode;
+    /** A document as a pill (the comparison's other side). Default: its name. */
+    renderDocumentPill?: (documentId: string) => ReactNode;
+    /** Open the host's share dialog for the document. Default: share it with the workspace. */
+    share?: (document: {
+        id: string;
+        name: string | undefined;
+        isPrivate: boolean;
+    }) => void;
+    /** Ask the assistant about a version (`doc-…@v2`) open read-only. Absent: not offered. */
+    askAboutVersion?: (versionRef: string) => void;
+    /** Translate the document (or the version) on screen. Absent: not offered. */
+    translate?: (documentRef: string) => void;
+    /** Start an image generation from the image on screen. Absent: not offered. */
+    useImageAsReference?: (documentId: string) => void;
+    /** The text (parsed) view of the document; the viewer gives it the page and zoom. */
+    renderParsedView?: (props: ParsedViewProps) => ReactNode;
+    /** How dates read (versions, signatures). Default: `fmtDate`. */
+    formatDate?: (iso: string) => string;
+    /** The viewer is shown in another window: PDF pages render without the page's web fonts. */
+    isDetached?: boolean;
+}
+/** What the viewer hands the text view. */
+export interface ParsedViewProps {
+    documentId: string;
+    onLoadSuccess: (totalPages: number) => void;
+    scrollTrigger: number;
+    zoom: number;
+    onZoomChange: (zoom: number) => void;
+}
+export declare function DocumentViewerSupportProvider({ value, children, }: {
+    value: DocumentViewerSupport;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useDocumentViewerSupport(): DocumentViewerSupport;

package/dist/connection/viewer/useImageCrop.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cropping an image in the viewer: the crop is saved as a NEW document made from the image
+ * (`derived_from`, role `crop`); the original is never touched. The new document opens once its id
+ * is back (otherwise it arrives through the documents list).
+ */
+export declare function useImageCrop(documentId: string, fileName: string | null | undefined, imageBlob: Blob | null): {
+    cropImageUrl: string | null;
+    handleOpenCrop: () => void;
+    closeCrop: () => void;
+    handleCropComplete: (result: {
+        blob: Blob;
+    }) => Promise<void>;
+};

package/dist/connection/viewer/useViewedDocument.d.ts

@@ -0,0 +1,70 @@
+/**
+ * What the document viewer is looking at: the document record, the host's streaming / draft overlay,
+ * the kind of content (artifact, live artifact, media, Word, sheet, ...) and whether it has parsed
+ * text.
+ */
+/** Lower-cased extension with its dot (`.pdf`), or `''`. */
+export declare function fileExtension(fileName: string | null | undefined): string;
+export declare function useViewedDocument(documentId: string): {
+    workspaceId: string | null;
+    documentData: NonNullable<NoInfer<{
+        external_id: string;
+        workspace_ext_id: string;
+        file_name?: string | null;
+        status?: string | null;
+        error_message?: string | null;
+        failed_stage?: string | null;
+        n_pages?: number | null;
+        n_chunks?: number | null;
+        tokens?: number | null;
+        file_type?: string | null;
+        file_size?: number | null;
+        storage_type?: string | null;
+        storage_uri?: string | null;
+        content_hash?: string | null;
+        shared?: boolean | null;
+        re_ocred?: boolean | null;
+        config_ext_id?: string | null;
+        parent_ext_id?: string | null;
+        current_version: number;
+        versions: import("@arbidocs/client").components["schemas"]["DocVersion"][];
+        thread_id?: string | null;
+        derived_from: import("@arbidocs/client").components["schemas"]["DerivedFrom"][];
+        source_message_ext_id?: string | null;
+        conversation_ext_id?: string | null;
+        created_by_ext_id: string;
+        updated_by_ext_id?: string | null;
+        created_at: string;
+        updated_at: string;
+        wp_type?: string | null;
+        folder?: string | null;
+        sender?: string | null;
+        doctags: import("@arbidocs/client").components["schemas"]["DocTagResponse"][];
+        doc_metadata?: import("@arbidocs/client").components["schemas"]["DocMetadata"] | null;
+    } | null>> | undefined;
+    streamingDoc: import("./support").ViewerStreamingDocument | undefined;
+    isStreaming: boolean;
+    draftDoc: import("./support").ViewerDraftDocument | undefined;
+    isDraft: boolean;
+    isCaptureDraft: boolean;
+    isTextDraft: boolean;
+    labelSummaries: import("../../files").DocTagSummary[];
+    isImage: boolean;
+    isWebmFile: boolean;
+    setWebmHasVideoTrack: import("react").Dispatch<import("react").SetStateAction<boolean | null>>;
+    isVideo: boolean;
+    isAudio: boolean;
+    isMedia: boolean;
+    isBlobArtifact: boolean;
+    savedDocumentId: string | null;
+    isArtifact: boolean;
+    liveKind: import("@arbidocs/react/artifacts").ArtifactPreviewKind | null;
+    liveSource: string;
+    isDocx: boolean;
+    isXlsx: boolean;
+    isEmail: boolean;
+    isDownloadOnly: boolean;
+    isParsedDocLoading: boolean;
+    hasParsedContent: boolean;
+};
+export type ViewedDocument = ReturnType<typeof useViewedDocument>;

package/dist/connection/viewer/useViewerBlobs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The bytes the document viewer shows: the PDF (or, for media, the stored file), with the host's
+ * copy kept on the device when the network is down; the stored sheet; the `.webm` track probe; and
+ * downloading the stored file.
+ */
+import type { ViewedDocument } from './useViewedDocument';
+/** `documentId` may be a version reference (`doc-…@v2`). */
+export declare function useViewerBlobs(documentId: string, doc: ViewedDocument): {
+    pdfBlob: Blob | null;
+    isPdfLoading: boolean;
+    pdfError: Error | null;
+    xlsxBlob: NoInfer<Blob> | null;
+    xlsxError: Error | null;
+    handleDirectDownload: () => Promise<void>;
+};

package/dist/connection/viewer/useViewerTabs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tabs of the document viewer: which tabs a document has, the automatic switches when the
+ * document's type or parsed content changes, and switching (which ends a comparison when leaving
+ * the tab that hosts it). The open tab is the session state's, so whatever opens a document can
+ * open it on a tab.
+ */
+import { type ArbiViewerTab } from '@arbidocs/react';
+import type { ViewerTab } from '../../files/ViewerParts';
+import type { ViewedDocument } from './useViewedDocument';
+/**
+ * @param hasHistory The document has earlier versions (a signed copy, a re-upload): PDF and text
+ *   documents then get a Versions tab too. Artifacts and Word documents always have one.
+ */
+export declare function useViewerTabs(doc: ViewedDocument, isCompact: boolean, hasHistory?: boolean): {
+    activeTab: ArbiViewerTab;
+    handleTabChange: (tabId: string) => void;
+    viewerTabs: ViewerTab[];
+};

package/dist/connection/viewer/useViewerVersions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A document's versions (oldest first; every row's `id` is a version reference) and its
+ * translations (each its own document, made from one of its versions). A listed document carries
+ * its versions, so it costs no request; one that is not in the workspace list asks for them.
+ */
+import { type ArtifactVersion } from '@arbidocs/react/artifacts';
+import type { TranslationEntry } from '../../artifacts/VersionTimeline';
+export declare function useViewerVersions(docId: string | null | undefined): {
+    versions: ArtifactVersion[];
+    translations: TranslationEntry[];
+};

package/dist/connection/workspace-settings/useConnectedWorkspaceSettings.d.ts

@@ -48,6 +48,12 @@ export declare function useConnectedWorkspaceSettings(workspaceId: string, { onL
         project_subscription?: string | null | undefined;
         project_owner_ext_id?: string | null | undefined;
         house_template_ext_id?: string | null | undefined;
+        archive?: {
+            status: "archiving" | "archived" | "restoring";
+            archived_at: string;
+            documents_done: number;
+            documents_total: number;
+        } | null | undefined;
     } | undefined;
     members: {
         user: {