@arbidocs/blocks 0.4.147 → 0.4.151

package/dist/connection/viewer/parsed/useChunkTagging.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Hook for managing chunk-level tagging
+ *
+ * Provides utilities for applying/removing tags to specific chunks
+ * within a document, and determining which tags apply to a chunk.
+ *
+ * Citations format: CitedDocument[] — a doc-first, best-first list of the
+ * documents (each with its cited chunks) backing the doctag's note. A doctag
+ * is grounded in passages, so a document that loses its last chunk drops out,
+ * and the doctag itself becomes ungrounded (null) once no documents remain.
+ */
+import type { components } from '@arbidocs/client';
+type CitationSources = components['schemas']['CitationSources'];
+type DocTag = components['schemas']['DocTagResponse'];
+type Tag = Pick<components['schemas']['TagResponse'], 'external_id'>;
+type Citations = CitationSources | null | undefined;
+interface UseChunkTaggingProps {
+    documentId: string;
+    documentDoctags: DocTag[];
+}
+interface ChunkTagState {
+    /** Tags that are applied to this specific chunk */
+    appliedTags: DocTag[];
+    /** Check if a specific tag is applied to this chunk */
+    isTagApplied: (tagExtId: string) => boolean;
+    /** Get the doctag for a specific tag if it applies to this chunk */
+    getDoctagForChunk: (tagExtId: string) => DocTag | undefined;
+}
+/** Every passage backing the doctag, document order then chunk order. */
+export declare function getAllChunkIdsFromCitations(citations: Citations): string[];
+/**
+ * Drop a passage. A doctag is grounded in passages, not whole documents, so a
+ * document that loses its last passage goes too; null once none remain, so an
+ * emptied doctag is ungrounded rather than grounded-in-nothing.
+ */
+export declare function removeChunkFromCitations(citations: Citations, chunkExtId: string): Citations;
+/** Add a passage under its document, ignoring duplicates. Order is the ranking. */
+export declare function addChunkToCitations(citations: Citations, documentId: string, chunkExtId: string): CitationSources;
+export declare function useChunkTagging({ documentId, documentDoctags }: UseChunkTaggingProps): {
+    getChunkTagState: (chunkExtId: string) => ChunkTagState;
+    toggleChunkTag: (chunkExtId: string, tag: Tag, note?: string) => Promise<void>;
+    updateChunkTagNote: (_chunkExtId: string, tag: Tag, note: string | null) => Promise<void>;
+    getChunkTagColors: (chunkExtId: string, workspaceTags: Tag[]) => string[];
+    isLoading: boolean;
+};
+export {};

package/dist/connection/viewer/parsed/useCitationSelection.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Passage selection for citations in the parsed viewer: drag-to-select, click / shift-click
+ * ranges, contiguous runs, the cited-run stepper, and the fact-citation highlight set.
+ */
+import type { RefObject } from 'react';
+import type { ProcessedPage } from '@arbidocs/react/viewers';
+interface Options {
+    documentId: string;
+    containerRef: RefObject<HTMLDivElement | null>;
+    processedChunks: ProcessedPage[];
+    orderedChunkIds: string[];
+    pageOf: (id: string) => number | undefined;
+}
+export declare function useCitationSelection({ documentId, containerRef, processedChunks, orderedChunkIds, pageOf, }: Options): {
+    isCitationMode: boolean;
+    selectedChunks: Set<string>;
+    selectionRuns: Map<string, import("@arbidocs/react/viewers").ChunkRunInfo>;
+    runStartIds: string[];
+    runCursor: number;
+    gotoRun: (delta: number) => void;
+    handleSelectionEnd: () => void;
+    handleChunkClick: (chunkId: string, extendFromAnchor: boolean) => void;
+    factCitationSet: Set<string>;
+    factCitationActive: boolean;
+    viewingPassageId: string | null;
+};
+export {};

package/dist/connection/viewer/parsed/useDocumentLabels.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Labels (doctags) on the parsed document: summaries, per-passage colours, the label being
+ * walked, and the passage being labelled. A doctag is anchored to the document, so its passages
+ * come with the document itself; no reverse lookup.
+ */
+import type { components } from '@arbidocs/client';
+type DocTag = components['schemas']['DocTagResponse'];
+/** One label marking a passage. */
+export interface PassageLabel {
+    tagExtId: string;
+    name: string;
+    color: string;
+}
+export declare function useDocumentLabels(documentId: string, doctags: DocTag[] | undefined, orderedChunkIds: string[]): {
+    documentDoctags: {
+        note?: string | null;
+        citations?: components["schemas"]["CitationSources"] | null;
+        external_id: string;
+        doc_ext_id: string;
+        tag_ext_id: string;
+        created_by_ext_id: string;
+        updated_by_ext_id?: string | null;
+        created_at: string;
+        updated_at: string;
+    }[];
+    labelSummaries: import("../../../files").DocTagSummary[];
+    labelsByChunk: Map<string, PassageLabel[]>;
+    removeLabel: (chunkExtId: string, tagExtId: string) => Promise<void>;
+    activeTagExtId: string | null;
+    activeTagColor: string | undefined;
+    activeChunkIds: Set<string>;
+    tagCursor: number;
+    gotoTagged: (delta: number) => void;
+    selectTag: (tagExtId: string | null) => void;
+    taggingChunkId: string | null;
+    setTaggingChunkId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+};
+export {};

package/dist/connection/viewer/parsed/useLazyPages.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lazy page rendering for the parsed viewer: only pages near the viewport render their chunks;
+ * the rest idle-fill, and a target page/passage (deep link, search, citation) is pre-rendered and
+ * scrolled into view.
+ */
+import type { RefObject } from 'react';
+import type { ProcessedPage } from '@arbidocs/react/viewers';
+interface Options {
+    containerRef: RefObject<HTMLDivElement | null>;
+    processedChunks: ProcessedPage[];
+    scrollTrigger?: number;
+}
+export declare function useLazyPages({ containerRef, processedChunks, scrollTrigger }: Options): {
+    renderedPages: Set<number>;
+    isChunkHighlighted: (chunkId: string) => boolean;
+    placeholderHeight: number;
+};
+export {};

package/dist/connection/viewer/parsed/usePageScrollSync.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Page Scroll Sync Hook
+ *
+ * Handles bidirectional page synchronization between HTML viewer and page controls.
+ * Manages tab switch scrolling, passage highlighting, and manual page navigation.
+ */
+interface UsePageScrollSyncProps {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    processedChunksLength: number;
+    scrollTrigger?: number;
+    /** Optional callback with visibility data for lazy loading */
+    onVisibilityUpdate?: (visibilityMap: Map<number, number>) => void;
+}
+export declare function usePageScrollSync({ containerRef, processedChunksLength, scrollTrigger, onVisibilityUpdate, }: UsePageScrollSyncProps): {
+    isChunkHighlighted: (chunkId: string) => boolean;
+};
+export {};

package/dist/connection/viewer/parsed/usePassageCopy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Passage Copy Hook
+ *
+ * Handles citation formatting and clipboard operations for document passages.
+ */
+import type { ViewerDocumentRecord } from '../support';
+interface PassageInfo {
+    type: 'link' | 'passage';
+    documentTitle: string;
+    pageNumber?: number;
+    passageIndex?: number;
+    passageContent: string;
+    href?: string;
+}
+interface UsePassageCopyProps {
+    documentId: string;
+    documentData: ViewerDocumentRecord | null | undefined;
+    selectedWorkspaceId: string | null;
+}
+export declare function usePassageCopy({ documentId, documentData, selectedWorkspaceId, }: UsePassageCopyProps): {
+    formatChunkWithCitation: (chunkContent: string, pageNumber?: number, chunkExtId?: string) => string;
+    getPassageDeepLink: (chunkExtId?: string) => string;
+    copyToClipboard: (text: string, passageInfo?: PassageInfo) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,97 @@
+/**
+ * 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;
+    /**
+     * A citation being edited elsewhere (a fact's sources, a field's) picks its passages in the text
+     * view: clicks and selections there are handed to it. Absent: passages are not pickable.
+     */
+    passageCitation?: PassageCitation;
+    /** Open the document's passages in the host's navigator (a passage's menu). Absent: not offered. */
+    openInNavigator?: (documentId: string) => void;
+    /** Start a new label or field in the host's editor (the passage tagging panel). Absent: not offered. */
+    createTag?: () => void;
+    /** 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;
+}
+/** A passage picked for a citation: its chunk and, when known, its page. */
+export interface PickedPassage {
+    chunk_id: string;
+    page?: number;
+}
+/** The citation a host is editing, as the text view sees it. */
+export interface PassageCitation {
+    /** The citation picking passages now, and the document it picks in; null when none is. */
+    active: {
+        documentId: string;
+        key: string | null;
+    } | null;
+    /** Passages to light (a fact's cited passages while its sources are open). */
+    highlighted: readonly string[];
+    /** Passages added to the citation. */
+    pick: (passages: PickedPassage[]) => void;
+    /** Passages taken off it. */
+    unpick: (chunkIds: string[]) => 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: {