@arbidocs/blocks 0.4.76 → 0.4.78

package/dist/tags/tagMatrixModel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The tag matrix as data: a parent label's child labels are the rows, the fields they share (the
+ * parent's, then any a row adds) the columns, and each row's linked documents and facts its
+ * evidence. Pure helpers for `TagMatrix`: the columns, a row's value, the gaps, and the snapshot
+ * as a Markdown document.
+ */
+import type { components } from '@arbidocs/client';
+export type TagMatrixData = components['schemas']['TagMatrixResponse'];
+export type TagMatrixRowData = components['schemas']['TagMatrixRow'];
+export type TagMatrixField = components['schemas']['TagField'];
+export type TagMatrixFieldType = TagMatrixField['type'];
+/**
+ * The columns: the parent's fields (shared by every row), then fields only some rows define,
+ * each once, in the order first seen. Mirrors the SDK's `tagMatrixColumns`.
+ */
+export declare function tagMatrixColumns(matrix: TagMatrixData | null | undefined): TagMatrixField[];
+/** A row's value for a column (values are keyed by field id). */
+export declare const cellValue: (row: TagMatrixRowData, column: TagMatrixField) => unknown;
+/** A row with nothing behind it: no linked document and no fact. */
+export declare const isGap: (row: TagMatrixRowData) => boolean;
+/** A value as text (a person by name, a checkbox as yes or no, blank as empty). */
+export declare function cellText(value: unknown, column: Pick<TagMatrixField, 'type'>, nameOf?: (id: string) => string | undefined): string;
+/** A typed input's text back as the value to store (`null` clears it). */
+export declare function parseCell(text: string, type: TagMatrixFieldType): unknown;
+export interface TagMatrixMarkdownOptions {
+    title: string;
+    /** The evidence column's heading. */
+    evidence?: string;
+    /** The row column's heading. */
+    rowHeading?: string;
+    nameOf?: (id: string) => string | undefined;
+    /** When the snapshot was taken (ISO); default now. */
+    at?: string;
+}
+/**
+ * The matrix as a Markdown document: a heading, when it was taken, and one table (a row per
+ * label, a column per field, then the evidence counts). What a host files or has signed.
+ */
+export declare function tagMatrixMarkdown(matrix: TagMatrixData, options: TagMatrixMarkdownOptions): string;

package/dist/workflow-canvas/StepActionSettings.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The inspector's settings for who a step is for and for the platform actions: the assignee
+ * picker and reminder, a document reference picker, and the settings of a signature, an email
+ * draft, a tabular review and an agent step that edits a document with tracked changes.
+ */
+import type { ReactNode } from 'react';
+import type { WorkflowAgentStep, WorkflowAssignee, WorkflowDocumentRef, WorkflowEmailDraftAction, WorkflowField, WorkflowSignAction, WorkflowStep, WorkflowTabularReviewAction } from '../agents';
+/** A choice the host supplies (a member, a label, a document). */
+export interface StepInspectorOption {
+    value: string;
+    label: string;
+}
+export interface StepActionSettingsLabels {
+    assignee: string;
+    assigneeAnyone: string;
+    assigneeRunOwner: string;
+    assigneeProjectLead: string;
+    /** The group of a run's person fields. */
+    assigneeFields: string;
+    assigneePeople: string;
+    remind: string;
+    remindHint: string;
+    documentFrom: string;
+    docFromStep: string;
+    docFromInput: string;
+    docById: string;
+    chooseStep: string;
+    chooseInput: string;
+    chooseDocument: string;
+    /** The id box when the host lists no documents. */
+    documentIdPlaceholder: string;
+    signDocument: string;
+    signers: string;
+    addSigner: string;
+    signMessage: string;
+    expires: string;
+    expiresHint: string;
+    emailTo: string;
+    emailCc: string;
+    emailSubject: string;
+    emailBody: string;
+    /** Under the address fields: separate several with commas. */
+    addressesHint: string;
+    /** Above the variables an email can use (click one to add it to the body). */
+    variablesHint: string;
+    attachments: string;
+    addAttachment: string;
+    reviewColumns: string;
+    noTags: string;
+    reviewDocuments: string;
+    reviewRunUploads: string;
+    reviewWorkspace: string;
+    reviewChosen: string;
+    addDocument: string;
+    overwrite: string;
+    editDocument: string;
+    editDocumentHint: string;
+}
+export declare const DEFAULT_STEP_ACTION_SETTINGS_LABELS: StepActionSettingsLabels;
+export declare const selectClass = "flex h-9 w-full rounded-md border border-input bg-background px-2 text-sm shadow-sm focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring";
+export declare function Field({ label, children, hint, }: {
+    label: string;
+    children: ReactNode;
+    hint?: string;
+}): import("react").JSX.Element;
+/** What the pickers can offer around the step being edited. */
+export interface StepContext {
+    /** The steps this one comes after (what its documents can come from). */
+    earlier: WorkflowStep[];
+    /** Every field of the run. */
+    fields: WorkflowField[];
+    people: StepInspectorOption[];
+    tags: StepInspectorOption[];
+    documents: StepInspectorOption[];
+}
+export declare function AssigneeSelect({ value, onChange, ctx, l, anyone, testId, ariaLabel, }: {
+    value: WorkflowAssignee | undefined;
+    onChange: (value: WorkflowAssignee | undefined) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    /** The "anyone" choice's wording; absent = no such choice. */
+    anyone?: string;
+    testId?: string;
+    ariaLabel?: string;
+}): import("react").JSX.Element;
+/** Who the step is for, and when they are reminded. */
+export declare function AssigneeSettings({ step, patch, ctx, l, testId, }: {
+    step: WorkflowStep;
+    patch: (p: Partial<WorkflowStep>) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;
+/** Where a document comes from: an earlier step, a run input, or one document. */
+export declare function DocumentRefPicker({ value, onChange, ctx, l, testId, }: {
+    value: WorkflowDocumentRef | undefined;
+    onChange: (value: WorkflowDocumentRef) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;
+export declare function SignSettings({ action, onChange, ctx, l, testId, }: {
+    action: WorkflowSignAction;
+    onChange: (action: WorkflowSignAction) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;
+/** The variables a template over the run can use: its fields and the earlier steps' answers. */
+export declare function templateVariables(ctx: StepContext): string[];
+export declare function EmailDraftSettings({ action, onChange, ctx, l, testId, }: {
+    action: WorkflowEmailDraftAction;
+    onChange: (action: WorkflowEmailDraftAction) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;
+export declare function TabularReviewSettings({ action, onChange, ctx, l, testId, }: {
+    action: WorkflowTabularReviewAction;
+    onChange: (action: WorkflowTabularReviewAction) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;
+/** "Edit this document (tracked changes)" on an agent step (main line only). */
+export declare function EditDocumentSettings({ step, patch, ctx, l, testId, }: {
+    step: WorkflowAgentStep;
+    patch: (p: Partial<WorkflowAgentStep>) => void;
+    ctx: StepContext;
+    l: StepActionSettingsLabels;
+    testId: string;
+}): import("react").JSX.Element;

package/dist/workflow-canvas/StepInspector.d.ts

@@ -2,8 +2,10 @@
  * The designer's side panel: the selected step's settings, or the workflow's own when nothing is
  * selected. Every edit goes through the pure operations in `./edit`.
  */
-import { type WorkflowDefinition } from '../agents';
+import { type WorkflowDefinition, type WorkflowField } from '../agents';
 import { type SignalsEditorLabels } from './SignalsEditor';
+import { type StepActionSettingsLabels, type StepInspectorOption } from './StepActionSettings';
+export type { StepInspectorOption } from './StepActionSettings';
 export interface StepInspectorLabels {
     workflow: string;
     title: string;
@@ -36,6 +38,9 @@ export interface StepInspectorLabels {
     hint: string;
     instructions: string;
     instructionsHint: string;
+    /** A review's fields: what the approver fills in. */
+    reviewFields: string;
+    reviewFieldsHint: string;
     deleteStep: string;
 }
 export declare const DEFAULT_STEP_INSPECTOR_LABELS: StepInspectorLabels;
@@ -47,12 +52,30 @@ export interface StepInspectorProps {
     onSelect?: (stepId: string | null) => void;
     /** What an agent step can run: skills and single-run workflows. */
     workflows?: WorkflowDefinition[];
+    /** The workspace's members: who a step is for, who signs. */
+    people?: StepInspectorOption[];
+    /** The workspace's labels: a tabular review's columns. */
+    tags?: StepInspectorOption[];
+    /** The workspace's documents: what a step names directly. */
+    documents?: StepInspectorOption[];
     labels?: Partial<StepInspectorLabels>;
+    /** The assignee and action settings' wording. */
+    actionLabels?: Partial<StepActionSettingsLabels>;
     /** The "When done, signal…" editor's wording. */
     signalLabels?: Partial<SignalsEditorLabels>;
     testId?: string;
 }
-export declare function StepInspector({ workflow, stepId, onChange, onSelect, workflows, labels, signalLabels, testId, }: StepInspectorProps): import("react").JSX.Element;
+export declare function StepInspector({ workflow, stepId, onChange, onSelect, workflows, people, tags, documents, labels, actionLabels, signalLabels, testId, }: StepInspectorProps): import("react").JSX.Element;
+/** The fields editor: a form's fields, a review's fields. */
+export declare function FormFields({ fields, taken, onChange, l, hint, testId, }: {
+    fields: WorkflowField[];
+    /** Codes used by other steps' fields: a field's code never collides with them. */
+    taken: string[];
+    onChange: (fields: WorkflowField[]) => void;
+    l: Pick<StepInspectorLabels, 'fields' | 'fieldLabel' | 'fieldType' | 'required' | 'addField'>;
+    hint?: string;
+    testId: string;
+}): import("react").JSX.Element;
 /**
  * A skill's inputs when it is picked: each one named like a field of the run reads that field
  * (`{{client}}`); the others start empty. What was typed before is kept.

package/dist/workflow-canvas/WorkflowBuilder.d.ts

@@ -6,8 +6,8 @@
  * thread that runs the steps.
  */
 import { type ReactNode } from 'react';
-import { type AgentOption, type StepComposeOptions, type WorkflowDefinition, type WorkflowGraphProblem } from '../agents';
-import { type StepInspectorLabels } from './StepInspector';
+import { type AgentOption, type StepComposeOptions, type WorkflowDefinition, type WorkflowGraphProblem, type WorkflowStepProblem } from '../agents';
+import { type StepInspectorLabels, type StepInspectorOption } from './StepInspector';
 import { type TriggerInspectorLabels } from './TriggerInspector';
 import { type DeclaredSignal, type WorkflowBuilderValue } from './trigger';
 import { type WorkflowCanvasLabels } from './WorkflowCanvas';
@@ -23,6 +23,8 @@ export interface WorkflowBuilderLabels {
     /** What the preview's stand-in agent answers; `{prompt}` is replaced. */
     previewAnswer: string;
     problems: Record<WorkflowGraphProblem['code'], string>;
+    /** What a step still needs (`{step}` is its title). */
+    missing: Record<WorkflowStepProblem['missing'], string>;
 }
 export declare const DEFAULT_WORKFLOW_BUILDER_LABELS: WorkflowBuilderLabels;
 export interface WorkflowBuilderProps extends Pick<StepComposeOptions, 'compose'> {
@@ -42,6 +44,12 @@ export interface WorkflowBuilderProps extends Pick<StepComposeOptions, 'compose'
         value: string;
         label: string;
     }>;
+    /** The workspace's members: who a step can be for, and who signs. */
+    people?: StepInspectorOption[];
+    /** The workspace's labels: a tabular review's columns. */
+    tags?: StepInspectorOption[];
+    /** The workspace's documents: what a step can name directly. */
+    documents?: StepInspectorOption[];
     /**
      * The signals the firm's workflows declare (`declaredSignals` over the saved workflows): what
      * "When a step signals" offers. The signals of the workflow being built are added.
@@ -57,4 +65,4 @@ export interface WorkflowBuilderProps extends Pick<StepComposeOptions, 'compose'
     testId?: string;
     className?: string;
 }
-export declare function WorkflowBuilder({ value, onChange, workflows, agents, eventKinds, tasks, signals, compose, renderIcon, actions, labels, canvasLabels, inspectorLabels, triggerLabels, testId, className, }: WorkflowBuilderProps): import("react").JSX.Element;
+export declare function WorkflowBuilder({ value, onChange, workflows, agents, eventKinds, tasks, signals, people, tags, documents, compose, renderIcon, actions, labels, canvasLabels, inspectorLabels, triggerLabels, testId, className, }: WorkflowBuilderProps): import("react").JSX.Element;

package/dist/workflow-canvas/WorkflowCanvas.d.ts

@@ -5,13 +5,18 @@
  * Read-only with live `phases` it shows a run's progress on the same graph.
  */
 import { type ReactNode } from 'react';
-import { type WorkflowDefinition, type WorkflowStepPhase } from '../agents';
+import { type WorkflowDefinition, type WorkflowStep, type WorkflowStepPhase } from '../agents';
 import { type WorkflowStepKind } from './edit';
 export interface WorkflowCanvasLabels {
     form: string;
     upload: string;
     agent: string;
     review: string;
+    sign: string;
+    email_draft: string;
+    tabular_review: string;
+    /** An agent step that edits a Word document with tracked changes. */
+    redline: string;
     /** An agent step that runs on a branch and delivers its result to the thread. */
     branch: string;
     /** What each kind is for, in the "+" menu. */
@@ -24,6 +29,21 @@ export interface WorkflowCanvasLabels {
     fields: string;
     noFields: string;
     approvedBy: string;
+    /** A signature step's summary; `{count}` is the number of signers. */
+    signers: string;
+    /** A signature step without its document yet. */
+    chooseDocument: string;
+    /** An email step's summary; `{to}` is its first recipient. */
+    emailTo: string;
+    /** An email step without a recipient yet. */
+    noRecipients: string;
+    /** A tabular review's summary; `{count}` is the number of columns (labels). */
+    reviewColumns: string;
+    noColumns: string;
+    /** A step's assignee on its card; `{name}` is replaced. */
+    assignee: string;
+    /** A step that reminds its person; `{hours}` is replaced. */
+    remind: string;
     emptyTitle: string;
     emptyHint: string;
     fitView: string;
@@ -43,6 +63,8 @@ export interface WorkflowCanvasProps {
     phases?: Record<string, WorkflowStepPhase>;
     /** Names the workflow an agent step runs (its card's summary). */
     workflowTitle?: (id: string) => string | undefined;
+    /** Who a step is for, in words (its card shows it). */
+    assigneeOf?: (step: WorkflowStep) => string | undefined;
     /**
      * The workflow's start, drawn as the first node (id `TRIGGER_NODE`): an edge from it into each
      * step that starts with the run. Drawing one from it into a step makes that step start the run.
@@ -65,5 +87,8 @@ export declare const STEP_KIND_ICONS: {
     readonly upload: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
     readonly agent: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
     readonly review: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly sign: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly email_draft: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly tabular_review: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
 };
-export declare function WorkflowCanvas({ workflow, onChange, selected, onSelect, focus, onAddAfter, phases, workflowTitle, trigger, renderIcon, labels, className, reserveRight, testId, }: WorkflowCanvasProps): import("react").JSX.Element;
+export declare function WorkflowCanvas({ workflow, onChange, selected, onSelect, focus, onAddAfter, phases, workflowTitle, assigneeOf, trigger, renderIcon, labels, className, reserveRight, testId, }: WorkflowCanvasProps): import("react").JSX.Element;

package/dist/workflow-canvas/edit.d.ts

@@ -8,7 +8,15 @@ type Steps = Extract<WorkflowDefinition['run'], {
     kind: 'steps';
 }>;
 export type WorkflowLayout = NonNullable<Steps['layout']>;
-export type WorkflowStepKind = WorkflowStep['kind'];
+/**
+ * What the builder's add menus offer: each kind of step, with each platform action (an
+ * `action` step) as a kind of its own.
+ */
+export type WorkflowStepKind = 'form' | 'upload' | 'agent' | 'review' | 'sign' | 'email_draft' | 'tabular_review';
+/** Every kind, in the order the add menus list them. */
+export declare const WORKFLOW_STEP_KINDS: readonly WorkflowStepKind[];
+/** A step's kind as the builder shows it: an action step is its action's type. */
+export declare const stepKindOf: (step: WorkflowStep) => WorkflowStepKind;
 /** A new, empty stepped workflow. */
 export declare function newSteppedWorkflow(id: string, title: string): WorkflowDefinition;
 /** A step id from a title: lowercase words joined by hyphens, unique within the workflow. */