@arbidocs/blocks 0.4.83 → 0.4.85

package/dist/connection/ConnectedTagTable.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `TagTable` bound to the connection: every tag of a kind in the workspace (`kind="issue"`: every
+ * issue), or with `parentId` a label's children. The columns are the kind's fields in the
+ * workspace (`useTagKindSchema`), edited in place and saved as the kind's schema
+ * (`useUpdateTagKindSchema`); the rows are the tag list filtered by kind with links (`useTags`),
+ * their cells saved with `useSetTagValues`. "Add row" creates a tag of the kind (issues, people
+ * and organisations are flat: no parent). The workspace's people fill person columns, and the
+ * snapshot is filed in the workspace as a Word document (`.docx`, so it opens in the Word editor;
+ * its id goes to `onExported`, so a host can open it or send it for signature) or downloaded.
+ */
+import type { components } from '@arbidocs/client';
+import { type TagTableProps } from '../tags/TagTable';
+/** What a tag is: a label, annotation, search, issue, person or organisation. */
+type TagKind = NonNullable<components['schemas']['TagResponse']['kind']>;
+export interface ConnectedTagTableProps extends Pick<TagTableProps, 'onOpenDocument' | 'onOpenFact' | 'onOpenThread' | 'onOpenRow' | 'actions' | 'labels' | 'className' | 'testId'> {
+    /** The rows are the workspace's tags of this kind, oldest first; the columns its fields. */
+    kind: TagKind;
+    /** Only this tag's children (a label hierarchy; flat kinds have none). */
+    parentId?: string;
+    /** How many documents, facts and threads each row lists (the rest are counted). Default 3. */
+    linksLimit?: number;
+    /** The exported document's title; default the kind's ("Issues", "People", …). */
+    exportTitle?: string;
+    /** The snapshot was filed: its document id. Absent: no export button. */
+    onExported?: (documentId: string) => void;
+    /** Offer the snapshot as a `.docx` download. Default true. */
+    downloadable?: boolean;
+    /** Read only: no cell edits, no "Add row", no column changes. */
+    readOnly?: boolean;
+}
+export declare function ConnectedTagTable({ kind, parentId, linksLimit, exportTitle, onExported, downloadable, readOnly, ...props }: ConnectedTagTableProps): import("react").JSX.Element;
+export {};

package/dist/connection/WorkflowRunnerDialogs.d.ts

@@ -5,6 +5,7 @@
  */
 export interface WorkflowRunnerDialogLabels {
     loadingDocument: string;
+    preparingDocument: string;
     documentFailed: string;
     reviewTitle: string;
     reviewDescription: string;
@@ -13,7 +14,17 @@ export interface WorkflowRunnerDialogLabels {
     wordTitle: string;
 }
 export declare const DEFAULT_WORKFLOW_RUNNER_DIALOG_LABELS: WorkflowRunnerDialogLabels;
-/** The sign flow on one document version: its PDF is fetched, then the blocks sign dialog. */
+/** How often, and how long apart, the PDF is fetched again while it is still being rendered. */
+export declare const SIGN_PDF_RETRIES = 4;
+export declare const SIGN_PDF_RETRY_DELAY_MS = 1500;
+/**
+ * The sign flow on one document version: its PDF is fetched, then the blocks sign dialog.
+ *
+ * What is signed is the PDF `GET /view?version=` serves (a Word or Markdown document's rendition),
+ * never the original's download, so the hash the server checks is of the bytes shown here. A
+ * rendition still being written is fetched again a few times; a version superseded since the step
+ * was set offers the current one instead.
+ */
 export declare function WorkflowSignDialog({ docRef, onClose, labels, }: {
     /** `doc-…` or `doc-…@v3`. */
     docRef: string;

package/dist/connection/mail/ConnectedMailAccounts.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+import { type MailAccount, type MailPolicy } from '@arbidocs/react';
+/** Whose names suggest the native address (`given.family`). */
+export interface MailAliasUser {
+    given_name?: string | null;
+    family_name?: string | null;
+}
+export interface ConnectedMailAccountsProps {
+    policy: MailPolicy;
+    accounts: MailAccount[];
+    onClose: () => void;
+    /** Render in place (e.g. a settings page) instead of a dialog. */
+    embedded?: boolean;
+    user?: MailAliasUser | null;
+    /** Where an OAuth provider returns after connecting. Default: the current page. */
+    oauthReturnPath?: string;
+    /** Extra settings under the accounts (e.g. keeping mail on this device). */
+    settings?: ReactNode;
+}
+/** Choose the native address, connect or remove external mailboxes. */
+export declare function ConnectedMailAccounts({ policy, accounts, onClose, embedded, user, oauthReturnPath, settings, }: ConnectedMailAccountsProps): import("react").JSX.Element;

package/dist/connection/mail/ConnectedMailComposer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The mail composer bound to the mail client in scope: write a new message, or open a saved draft
+ * (`draftId`), save it to Drafts and send it, with files and workspace documents attached.
+ *
+ * Inside `ConnectedMailbox` everything is passed in; on its own it finds what it needs: the account
+ * (`mailbox`, default the native inbox), the attachment limit, the unlock and the saved drafts.
+ */
+import { type RefObject } from 'react';
+import { type MailAccount, type MailCompose, type MailMessage } from '@arbidocs/react';
+import type { MailDocumentSource, MailNotify, MailOfflineSupport } from './types';
+export interface ConnectedMailComposerProps {
+    /** Open this saved draft (from the account's Drafts) instead of a new message. */
+    draftId?: string;
+    /** The message to start from (new, reply, forward). Default: empty, or the draft. */
+    initial?: MailCompose;
+    /** Send from this account. Default: the `mailbox` account. */
+    account?: MailAccount;
+    /** Which account to send from when `account` is not given: an id, or `'native'` (default). */
+    mailbox?: string;
+    /** The attachment limit. Default: the deployment's. */
+    maxBytes?: number;
+    /** Whether saving and sending can run. Default: once the account is unlocked (or offline). */
+    ready?: boolean;
+    /** Saved drafts, for the "already in Drafts" notice. Default: the account's Drafts. */
+    drafts?: MailMessage[];
+    onClose: () => void;
+    onOpenDraft?: (id: string) => void;
+    onChange?: (value: MailCompose) => void;
+    /** Fill the parent (a panel) instead of opening as a dialog. */
+    embedded?: boolean;
+    /** Receives the close request (asks before discarding unsaved changes). */
+    closeRequestRef?: RefObject<(() => void) | null>;
+    /** Editing a draft kept on this device (see {@link MailOfflineSupport}). */
+    localDraftId?: string;
+    offline?: MailOfflineSupport;
+    /** Workspace documents to attach ("From workspace"). Absent: not offered. */
+    documents?: MailDocumentSource;
+    notify?: MailNotify;
+}
+export declare function ConnectedMailComposer({ draftId, initial, account: accountProp, mailbox, maxBytes: maxBytesProp, ready: readyProp, drafts: draftsProp, notify, offline, ...rest }: ConnectedMailComposerProps): import("react").JSX.Element;

package/dist/connection/mail/ConnectedMailSetup.d.ts

@@ -0,0 +1,16 @@
+import { type MailPolicy } from '@arbidocs/react';
+import type { MailAliasUser } from './ConnectedMailAccounts';
+/**
+ * First run of Mail, in the main screen rather than a dialog: the user confirms the suggested
+ * address and is straight into their inbox. External accounts (Gmail, Outlook, IMAP) stay one
+ * click away, in the accounts dialog, for deployments that enable them.
+ */
+export declare function ConnectedMailSetup({ policy, user, productName, onClaimed, onConnectExisting, }: {
+    policy: MailPolicy;
+    user?: MailAliasUser | null;
+    /** The product's name in the copy ("Set up your ARBI email"). Default: none. */
+    productName?: string;
+    /** The inbox exists now (the alias that was claimed). */
+    onClaimed: (alias: string) => void;
+    onConnectExisting: () => void;
+}): import("react").JSX.Element;

package/dist/connection/mail/ConnectedMailbox.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The whole mail screen bound to the mail client in scope (`MailClientProvider`, else the
+ * `ArbiProvider` session): first-run setup or the accounts, the folder picker and filter, the message
+ * list, the reader and the composer.
+ *
+ * The host owns navigation: it can ask for a draft (`draftId`), a folder (`folder`) or a new message
+ * with attachments (`composeAttachments`); each is taken once and reported back (`on…Opened`), so
+ * asking again for the same thing works. Device storage (offline reading, the Outbox), workspace
+ * documents and saving to a workspace are optional host capabilities passed as props.
+ */
+import { type ReactNode } from 'react';
+import type { GridState } from 'ag-grid-community';
+import { type MailAddress, type MailAttachment } from '@arbidocs/react';
+import { type MailAliasUser } from './ConnectedMailAccounts';
+import type { MailDocumentSource, MailNotify, MailOfflineSupport, MailPanelProps, MailSaveToWorkspace } from './types';
+export interface ConnectedMailboxProps {
+    /** Which mailbox: an account id, or `'native'` for the user's own inbox. Default: the first. */
+    mailbox?: string;
+    /** Open this draft (in the native mailbox's Drafts); taken once, then `onDraftOpened`. */
+    draftId?: string | null;
+    onDraftOpened?: () => void;
+    /** Open this folder (a role such as `inbox`, or an id); taken once, then `onFolderOpened`. */
+    folder?: string | null;
+    onFolderOpened?: () => void;
+    /** Start a new message with these attachments; taken once, then `onComposeOpened`. */
+    composeAttachments?: MailAttachment[] | null;
+    onComposeOpened?: () => void;
+    /**
+     * Open a document: offered as "Open" on the notice after an email is saved into a workspace
+     * (when `saveToWorkspace.save` resolves with the new document's id).
+     */
+    onOpenDocument?: (documentId: string, workspaceId: string) => void;
+    /** The user, for the suggested native address (`given.family`). */
+    user?: MailAliasUser | null;
+    /** The product's name in the setup copy ("Set up your ARBI email"). */
+    productName?: string;
+    /** Where an OAuth provider returns after connecting. Default: the current page. */
+    oauthReturnPath?: string;
+    /** How a person is named (e.g. from contacts). Default: the name on the message, else the address. */
+    personLabel?: (person: MailAddress) => string;
+    /** Device storage: offline reading, the Outbox, drafts written offline. Absent: online only. */
+    offline?: MailOfflineSupport;
+    /** The open workspace's documents, attachable in the composer. */
+    documents?: MailDocumentSource;
+    /** Saving an email into a workspace ("Save to workspace" on native mail). */
+    saveToWorkspace?: MailSaveToWorkspace;
+    /** A calendar invite card for a message with an .ics part. */
+    renderInvite?: (props: {
+        accountId: string;
+        messageId: string;
+        attachments: MailAttachment[];
+        isOnline: boolean;
+    }) => ReactNode;
+    /** Where the reader and composer open. Default: a panel beside the list. */
+    renderPanel?: (props: MailPanelProps) => ReactNode;
+    /** The reader or composer opened or closed. */
+    onViewerOpenChange?: (open: boolean) => void;
+    /** The message list's column state, and where to persist it. */
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+    /** The message opened first (e.g. restored after a redirect). */
+    initialMessageId?: string | null;
+    notify?: MailNotify;
+}
+export declare function ConnectedMailbox({ mailbox, draftId, onDraftOpened, folder: requestedFolder, onFolderOpened, composeAttachments, onComposeOpened, onOpenDocument, user, productName, oauthReturnPath, personLabel, offline, documents, saveToWorkspace, renderInvite, renderPanel, onViewerOpenChange, gridState, onGridStateChange, initialMessageId, notify, }: ConnectedMailboxProps): import("react").JSX.Element;

package/dist/connection/mail/MailComposerForm.d.ts

@@ -0,0 +1,25 @@
+import { type RefObject } from 'react';
+import { type MailAccount, type MailCompose, type MailMessage } from '@arbidocs/react';
+import type { MailDocumentSource, MailNotify, MailOfflineSupport } from './types';
+export interface MailComposerFormProps {
+    account?: MailAccount;
+    initial: MailCompose;
+    maxBytes: number;
+    ready: boolean;
+    /** The account's saved drafts: a new message with a draft's subject points to it. */
+    drafts: MailMessage[];
+    onClose: () => void;
+    /** Open a saved draft (from the "already in Drafts" notice). Absent: the notice has no button. */
+    onOpenDraft?: (id: string) => void;
+    /** Reports every edit so the parent can re-seed this form if it remounts (e.g. docked → overlay). */
+    onChange?: (value: MailCompose) => void;
+    embedded?: boolean;
+    closeRequestRef?: RefObject<(() => void) | null>;
+    /** Editing a draft kept on this device (saved offline): saves update it, sending removes it. */
+    localDraftId?: string;
+    offline?: MailOfflineSupport;
+    documents?: MailDocumentSource;
+    notify: MailNotify;
+}
+/** Write, save and send one message. */
+export declare function MailComposerForm({ account, initial, maxBytes, ready, drafts, onClose, onOpenDraft, onChange, embedded, closeRequestRef, localDraftId: initialLocalDraftId, offline, documents, notify, }: MailComposerFormProps): import("react").JSX.Element;

package/dist/connection/mail/attachments.d.ts

@@ -0,0 +1,13 @@
+import { type MailAccount, type MailAttachment, type MailClient } from '@arbidocs/react';
+import type { MailOfflineSupport } from './types';
+export declare function attachmentPath(accountId: string, messageId: string, attachmentId: string): string;
+/** Hand a file to the browser as a download. */
+export declare function saveFile(blob: Blob, name: string): void;
+/**
+ * A message's attachments with their content, for a forward or a reopened draft. Offline, each
+ * comes from this device (or arrives without content, and Send then names the missing file).
+ */
+export declare function hydrateMailAttachments(client: MailClient, account: MailAccount, messageId: string, attachments: MailAttachment[], { isOnline, offline }: {
+    isOnline: boolean;
+    offline?: MailOfflineSupport;
+}): Promise<MailAttachment[]>;

package/dist/connection/mail/index.d.ts

@@ -0,0 +1,6 @@
+export { ConnectedMailbox, type ConnectedMailboxProps } from './ConnectedMailbox';
+export { ConnectedMailComposer, type ConnectedMailComposerProps } from './ConnectedMailComposer';
+export { defaultMailNotify, resolveMailbox } from './mailbox';
+export { ConnectedMailAccounts, type ConnectedMailAccountsProps, type MailAliasUser, } from './ConnectedMailAccounts';
+export { ConnectedMailSetup } from './ConnectedMailSetup';
+export type { MailNotify, MailLocalDraft, MailOutboxEntry, MailOutboxRequest, MailOfflineSupport, MailDocumentSource, MailSaveToWorkspace, MailPanelProps, } from './types';

package/dist/connection/mail/mailbox.d.ts

@@ -0,0 +1,6 @@
+import { type MailAccount } from '@arbidocs/react';
+import type { MailNotify } from './types';
+/** The default {@link MailNotify}: the shared toast and notification centre. */
+export declare const defaultMailNotify: MailNotify;
+/** The account a `mailbox` choice names: an account id, or `'native'` for the user's own inbox. */
+export declare function resolveMailbox(accounts: MailAccount[] | undefined, mailbox: string | undefined): MailAccount | undefined;

package/dist/connection/mail/types.d.ts

@@ -0,0 +1,92 @@
+import type { ReactNode } from 'react';
+import type { MailAccount, MailAttachment, MailCompose } from '@arbidocs/react';
+import type { MailAttachableDocument } from '../../collaboration/mail/MailDocumentPicker';
+/** Tell the user how an action went (a toast). Default: `notify` from `@arbidocs/react`. */
+export type MailNotify = (message: string, variant: 'success' | 'info' | 'error', options?: {
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}) => void;
+/** A draft kept on this device (written offline), not yet in the server's Drafts. */
+export interface MailLocalDraft {
+    id: string;
+    compose: MailCompose;
+    /** Epoch milliseconds. */
+    updatedAt: number;
+    /** Why it could not be uploaded, if it could not. */
+    error?: string;
+}
+/** A message waiting in the device Outbox. */
+export interface MailOutboxEntry {
+    account: {
+        id: string;
+    };
+    status: string;
+    compose: MailCompose;
+}
+/** A message for the device Outbox: sent later with this `requestId`, so it can only go out once. */
+export interface MailOutboxRequest {
+    account: MailAccount;
+    compose: MailCompose;
+    requestId: string;
+    secure: boolean;
+    /** The prepared secure-delivery payload, when `secure`. */
+    securePayload?: unknown;
+}
+/**
+ * A host that keeps mail on the device (offline reading, an Outbox, drafts written offline).
+ * Without it the mailbox is online only. The `use*` members are hooks: the mailbox calls them on
+ * every render, so pass a stable object (e.g. a module constant).
+ */
+export interface MailOfflineSupport {
+    /** The folder role of the Outbox; a device Outbox is added when the server has none. */
+    outboxRole: string;
+    useLocalDrafts(accountId: string | undefined): MailLocalDraft[];
+    useOutbox(): MailOutboxEntry[];
+    /** The Outbox folder's contents (shown above its list). */
+    renderOutbox(props: {
+        accountId: string;
+        onEdit: (compose: MailCompose) => void;
+    }): ReactNode;
+    /** A status line under the header (what is saved on this device, sync state). */
+    renderStatus?(): ReactNode;
+    /** Per-device settings, in the accounts dialog. */
+    renderSettings?(): ReactNode;
+    /** An attachment saved on this device, as a file (undefined when it wasn't saved). */
+    loadAttachment(accountId: string, messageId: string, attachment: MailAttachment): Promise<File | undefined>;
+    /** Keep a draft on this device; `localDraftId` updates the one already there. */
+    saveDraft(accountId: string, compose: MailCompose, localDraftId?: string): Promise<{
+        id: string;
+    }>;
+    deleteDraft(localDraftId: string): Promise<void>;
+    /** Put a message in the Outbox; rejects with the reason when it can't wait there. */
+    queueSend(request: MailOutboxRequest): Promise<void>;
+    /** The request never got an answer (no connection), as opposed to the server refusing it. */
+    isNetworkFailure(error: unknown): boolean;
+}
+/** The open workspace's documents, attachable to an email as their files. */
+export interface MailDocumentSource {
+    documents: MailAttachableDocument[];
+    /** The document's file as an attachment; rejects when it can't be fetched or exceeds `maxBytes`. */
+    toAttachment(documentId: string, maxBytes: number): Promise<MailAttachment>;
+}
+/** Saving an email (its .eml) into a workspace. */
+export interface MailSaveToWorkspace {
+    workspaces: {
+        id: string;
+        name: string;
+    }[];
+    /** Preselected in the dialog (e.g. the open workspace). Default: the first. */
+    defaultWorkspaceId?: string | null;
+    /** Upload the .eml; resolves with the new document's id when known. */
+    save(workspaceId: string, file: File): Promise<string | void>;
+}
+/** Where the reader and the composer open. */
+export interface MailPanelProps {
+    isOpen: boolean;
+    title: string;
+    onClose: () => void;
+    children: ReactNode;
+}

package/dist/connection/useConnectedWorkNotifications.d.ts

@@ -8,6 +8,12 @@ export type WorkNotificationTarget = {
     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>): {

package/dist/connection/useWorkflowThread.d.ts

@@ -3,14 +3,19 @@
  * steps; its activity log says where each step is; the work runner starts each agent step as a
  * turn in the thread. This hook reads all of that and does the person's part: it starts the thread
  * (with the run's inputs and the steps' prompts composed from them), completes forms, uploads and
- * reviews, skips, and retries a failed step. `WorkflowRunner` shows the result.
+ * reviews, skips, and retries a failed step. A run whose first open step is an agent or action
+ * step starts when the person presses Start: the thread is created and the server starts that
+ * step. `WorkflowRunner` shows the result.
  */
 import { type ConversationResponse } from '@arbidocs/react';
 import { type StepComposeOptions } from '../agents/workflows/run';
 import { type WorkflowRunView } from '../agents/workflows/useWorkflowView';
 import type { WorkflowDefinition, WorkflowInputs } from '../agents/workflows/types';
 export interface UseWorkflowThreadOptions extends StepComposeOptions {
-    /** An existing run to show (its thread). Absent: a new run starts when its first step is done. */
+    /**
+     * An existing run to show (its thread). Absent: a new run starts when its first step is done,
+     * or, when that is an agent or action step, when the person starts it.
+     */
     conversationId?: string;
     /** The thread was created (store its id to come back to the run). */
     onStarted?: (conversationId: string) => void;

package/dist/document-tools/SignDocumentDialog.d.ts

@@ -12,9 +12,16 @@ export interface SignDocumentDialogProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
     documentId: string;
-    /** The PDF the viewer is showing. */
+    /** The PDF the viewer is showing: `GET /view?version=`, never the original's download. */
     pdfBlob: Blob;
+    /** The version `pdfBlob` is of; omitted = the current version. */
+    version?: number;
     /** Where the signature goes; omitted = bottom of the last page. */
     appearance?: SignatureAppearance;
+    /**
+     * Open the current version when the one shown has been superseded (only the current version can
+     * be signed). Default: the host's `openDocument` on the document, after the dialog closes.
+     */
+    onOpenCurrent?: () => void;
 }
-export declare function SignDocumentDialog({ open, onOpenChange, documentId, pdfBlob, appearance, }: SignDocumentDialogProps): ReactElement;
+export declare function SignDocumentDialog({ open, onOpenChange, documentId, pdfBlob, version, appearance, onOpenCurrent, }: SignDocumentDialogProps): ReactElement;

package/dist/document-tools/index.cjs

@@ -1,7 +1,7 @@
 "use client";
 'use strict';
 
-var chunkZVBPRMHJ_cjs = require('../chunk-ZVBPRMHJ.cjs');
+var chunkJH6JTI76_cjs = require('../chunk-JH6JTI76.cjs');
 var chunk4DVEGXZQ_cjs = require('../chunk-4DVEGXZQ.cjs');
 require('../chunk-ULWRNGGE.cjs');
 require('../chunk-DES3K4SD.cjs');
@@ -482,7 +482,7 @@ function VersionSnapshotBar({
 
 Object.defineProperty(exports, "SignDocumentDialog", {
   enumerable: true,
-  get: function () { return chunkZVBPRMHJ_cjs.SignDocumentDialog; }
+  get: function () { return chunkJH6JTI76_cjs.SignDocumentDialog; }
 });
 exports.AnnotateButton = AnnotateButton;
 exports.DEFAULT_VERSION_SNAPSHOT_BAR_LABELS = DEFAULT_VERSION_SNAPSHOT_BAR_LABELS;

package/dist/document-tools/index.js

@@ -1,5 +1,5 @@
 "use client";
-export { SignDocumentDialog } from '../chunk-FE4ULGOR.js';
+export { SignDocumentDialog } from '../chunk-2YOVK524.js';
 import { ViewerStatusNote } from '../chunk-ODWCTAH7.js';
 import '../chunk-TX2ZICS7.js';
 import '../chunk-VUNV25KB.js';

package/dist/facts/index.cjs

@@ -7,11 +7,11 @@ var chunkVPPX5XUF_cjs = require('../chunk-VPPX5XUF.cjs');
 var chunk7RGLTF76_cjs = require('../chunk-7RGLTF76.cjs');
 var chunkV4ISCZJ7_cjs = require('../chunk-V4ISCZJ7.cjs');
 var chunk2EI7NCUA_cjs = require('../chunk-2EI7NCUA.cjs');
-var chunkIXALYQT7_cjs = require('../chunk-IXALYQT7.cjs');
-require('../chunk-FX3K6LNZ.cjs');
 var chunkPPCATBOY_cjs = require('../chunk-PPCATBOY.cjs');
 require('../chunk-C54XEN5T.cjs');
 var chunkKDG6FER6_cjs = require('../chunk-KDG6FER6.cjs');
+var chunkIXALYQT7_cjs = require('../chunk-IXALYQT7.cjs');
+require('../chunk-FX3K6LNZ.cjs');
 var chunkMHVNT4J3_cjs = require('../chunk-MHVNT4J3.cjs');
 require('../chunk-DES3K4SD.cjs');
 var lucideReact = require('lucide-react');

package/dist/facts/index.js

@@ -6,11 +6,11 @@ import { TabHeader } from '../chunk-4WWM3GQ5.js';
 import { SelectionBar, SelectionBarAction } from '../chunk-NUNKSZKU.js';
 import { FilterInput } from '../chunk-YU2KUMGE.js';
 export { DEFAULT_FILTER_INPUT_LABELS as DEFAULT_FACTS_FILTER_INPUT_LABELS, DEFAULT_FILTER_FIELDS as FACTS_SEARCH_FIELD_OPTIONS, FilterInput as FactsFilterInput } from '../chunk-YU2KUMGE.js';
-import { GridView } from '../chunk-ZPLG7QYF.js';
-import '../chunk-SLSBJRWW.js';
 import { observeResize } from '../chunk-NPLYHR2E.js';
 import '../chunk-76JDDMSP.js';
 import { initials } from '../chunk-OXF2IFXG.js';
+import { GridView } from '../chunk-ZPLG7QYF.js';
+import '../chunk-SLSBJRWW.js';
 import { testIdOr } from '../chunk-7F6CBP3Z.js';
 import '../chunk-VUNV25KB.js';
 import { PencilLine, Check, MoreVertical, Pencil, Trash2, CalendarDays, X, Columns3, ChevronDown, RotateCcw, Milestone, CalendarClock, Scale, Lightbulb, ArrowRight, Loader2, Info, Paperclip, Tags, MoreHorizontal, FolderUp, BookMarked, Plus, Search, CheckCircle2, CornerDownLeft, Quote, ChevronLeft, ChevronRight, Table2, CalendarRange, GanttChartSquare } from 'lucide-react';