@arbidocs/blocks 0.4.84 → 0.4.85

package/dist/shell/index.cjs

@@ -7,9 +7,9 @@ var chunk2EI7NCUA_cjs = require('../chunk-2EI7NCUA.cjs');
 require('../chunk-OB5F4577.cjs');
 var chunkXKSFJYOD_cjs = require('../chunk-XKSFJYOD.cjs');
 var chunkVGOFFCMT_cjs = require('../chunk-VGOFFCMT.cjs');
-var chunkFX3K6LNZ_cjs = require('../chunk-FX3K6LNZ.cjs');
 require('../chunk-PPCATBOY.cjs');
 require('../chunk-C54XEN5T.cjs');
+var chunkFX3K6LNZ_cjs = require('../chunk-FX3K6LNZ.cjs');
 require('../chunk-MHVNT4J3.cjs');
 require('../chunk-DES3K4SD.cjs');
 

package/dist/shell/index.js

@@ -5,9 +5,9 @@ export { DEFAULT_FILTER_FIELDS, DEFAULT_FILTER_INPUT_LABELS, FilterInput } from
 import '../chunk-S7PSMMRG.js';
 export { DEFAULT_DOCK_WIDTH, Toaster } from '../chunk-BV7FEMSI.js';
 export { DEFAULT_OVERLAY_ZONE_ID, DEFAULT_PAGE_CONTAINER_PADDING, DEFAULT_SIDEBAR_TOGGLE_BUTTON_LABELS, PageContainer, SHELL_BOTTOM_INSET_VAR, Shell, SidebarToggleButton, ToolButton, useDrawerBehavior, useOverlayZoneId, useShellBottomInset } from '../chunk-KZJAG7T3.js';
-export { BREAKPOINT_QUERIES, useIsNarrow, useIsPhone, useIsTouchScreen, useMediaQuery } from '../chunk-SLSBJRWW.js';
 import '../chunk-NPLYHR2E.js';
 import '../chunk-76JDDMSP.js';
+export { BREAKPOINT_QUERIES, useIsNarrow, useIsPhone, useIsTouchScreen, useMediaQuery } from '../chunk-SLSBJRWW.js';
 import '../chunk-7F6CBP3Z.js';
 import '../chunk-VUNV25KB.js';
 //# sourceMappingURL=index.js.map

package/dist/tags/TagColumnsEditor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The columns of a table of tags — the fields of their kind in the workspace (its issue fields …) —
+ * edited as one list: rename, reorder by position, add, remove, and a choice field's options. A kept
+ * column keeps its id, so its values stay (its type is fixed once created). Saved in full through
+ * the host (`onSave`); data-free.
+ */
+import type { TagTableField, TagTableFieldType, TagTableFieldWrite } from './tagTableModel';
+export interface TagColumnsEditorLabels {
+    title: string;
+    addColumn: string;
+    name: string;
+    type: string;
+    options: string;
+    optionsPlaceholder: string;
+    remove: string;
+    moveUp: string;
+    moveDown: string;
+    save: string;
+    saving: string;
+    cancel: string;
+    empty: string;
+    types: Record<TagTableFieldType, string>;
+}
+export declare const DEFAULT_TAG_COLUMNS_EDITOR_LABELS: TagColumnsEditorLabels;
+export interface TagColumnsEditorProps {
+    columns: TagTableField[];
+    /** Save the columns in full; a rejection (e.g. two columns of one name) stays on screen. */
+    onSave: (fields: TagTableFieldWrite[]) => void | Promise<unknown>;
+    onCancel: () => void;
+    labels?: Partial<TagColumnsEditorLabels>;
+    className?: string;
+    testId?: string;
+}
+export declare function TagColumnsEditor({ columns, onSave, onCancel, labels, className, testId, }: TagColumnsEditorProps): import("react").JSX.Element;

package/dist/tags/TagDetail.d.ts

@@ -1,11 +1,11 @@
 /**
- * One tag in full: its own fields (aliases, role, status, …) editable in place, then everything
- * across the workspace that carries it — the documents (with the value or note the tag has on
- * each, and how many passages back it), the facts and the threads. The data is one row of the tag matrix
- * (`TagMatrixRowData`); every write goes back through the host.
+ * One tag in full: its values for its kind's fields (position, role, status, …) editable in place,
+ * then everything across the workspace that carries it — the documents (with the value or note the
+ * tag has on each, and how many passages back it), the facts and the threads. The data is the tag
+ * read with its links (`TagTableRow`) and its kind's fields; every write goes back through the host.
  */
-import { type TagMatrixLabels, type TagMatrixProps } from './TagMatrix';
-import type { TagMatrixRowData } from './tagMatrixModel';
+import { type TagTableLabels, type TagTableProps } from './TagTable';
+import { type TagTableField, type TagTableRow } from './tagTableModel';
 export interface TagDetailLabels {
     fields: string;
     documents: string;
@@ -25,14 +25,16 @@ export interface TagDetailLabels {
     loading: string;
 }
 export declare const DEFAULT_TAG_DETAIL_LABELS: TagDetailLabels;
-export interface TagDetailProps extends Pick<TagMatrixProps, 'onChangeValue' | 'onOpenDocument' | 'onOpenFact' | 'onOpenThread' | 'people'> {
-    /** The tag's matrix row (its fields, values, documents and facts). */
-    row: TagMatrixRowData | undefined;
+export interface TagDetailProps extends Pick<TagTableProps, 'onChangeValue' | 'onOpenDocument' | 'onOpenFact' | 'onOpenThread' | 'people'> {
+    /** The tag with its values and links (documents, facts, threads). */
+    row: TagTableRow | undefined;
+    /** Its kind's fields in the workspace (none: no Fields section). */
+    fields?: TagTableField[];
     isLoading?: boolean;
     labels?: Partial<TagDetailLabels>;
     /** Labels of the field inputs (the empty choice). */
-    fieldLabels?: Partial<TagMatrixLabels>;
+    fieldLabels?: Partial<TagTableLabels>;
     className?: string;
     testId?: string;
 }
-export declare function TagDetail({ row, isLoading, people, onChangeValue, onOpenDocument, onOpenFact, onOpenThread, labels, fieldLabels, className, testId, }: TagDetailProps): import("react").JSX.Element;
+export declare function TagDetail({ row, fields, isLoading, people, onChangeValue, onOpenDocument, onOpenFact, onOpenThread, labels, fieldLabels, className, testId, }: TagDetailProps): import("react").JSX.Element;

package/dist/tags/TagTable.d.ts

@@ -0,0 +1,99 @@
+/**
+ * A table of tags (every issue, every person, a label's children): one row per tag, a column per
+ * field of their kind in the workspace, editable in place by type (text, number, date, checkbox,
+ * choice, person), and the evidence behind each row (its linked documents, facts and threads, with
+ * counts). Rows with no evidence are marked as gaps. Rows and columns can be added (the columns are
+ * the kind's fields, edited as one list), and the table exported as a Word document snapshot (filed
+ * in the workspace) or downloaded.
+ * The data and every write come from the host (`ConnectedTagTable` binds them to ARBI).
+ */
+import { type ReactNode } from 'react';
+import { type TagTableData, type TagTableField, type TagTableFieldWrite, type TagTableRow } from './tagTableModel';
+import { type TagColumnsEditorLabels } from './TagColumnsEditor';
+export interface TagTableLabels {
+    row: string;
+    evidence: string;
+    /** `{count}` documents linked. */
+    documents: string;
+    /** `{count}` facts linked. */
+    facts: string;
+    /** `{count}` threads linked. */
+    threads: string;
+    /** One document, one fact, one thread. */
+    document: string;
+    fact: string;
+    thread: string;
+    /** A thread without a title. */
+    untitledThread: string;
+    /** `{count}` more links than shown. */
+    more: string;
+    gap: string;
+    gapsOnly: string;
+    /** `{count}` rows without evidence. */
+    gapCount: string;
+    addRow: string;
+    addRowPlaceholder: string;
+    add: string;
+    export: string;
+    exporting: string;
+    download: string;
+    empty: string;
+    loading: string;
+    noColumns: string;
+    choose: string;
+    yes: string;
+    /** Opens the column editor. */
+    editColumns: string;
+    /** The column editor's own labels. */
+    columns?: Partial<TagColumnsEditorLabels>;
+}
+export declare const DEFAULT_TAG_TABLE_LABELS: TagTableLabels;
+export interface TagTableProps {
+    /** The kind's fields (the columns) and its tags (the rows, with their links). */
+    table: TagTableData | undefined;
+    isLoading?: boolean;
+    /** Change one cell (`null` clears it). Absent: read only. */
+    onChangeValue?: (tagId: string, fieldId: string, value: unknown) => void | Promise<unknown>;
+    /** Add a row (a new tag of the kind). Absent: no "Add row". */
+    onAddRow?: (name: string) => void | Promise<unknown>;
+    /**
+     * Set the columns (the kind's fields) in full: a kept column has its `id`. Absent: the columns
+     * are fixed.
+     */
+    onChangeColumns?: (fields: TagTableFieldWrite[]) => void | Promise<unknown>;
+    /** Open a linked document. */
+    onOpenDocument?: (documentId: string) => void;
+    /** Open a linked fact. */
+    onOpenFact?: (factId: string) => void;
+    /** Open a linked thread (conversation). */
+    onOpenThread?: (conversationId: string) => void;
+    /** Open a row's tag (all its evidence). */
+    onOpenRow?: (tagId: string) => void;
+    /** Export the table as it stands (filed as a document). Absent: no export button. */
+    onExport?: () => void | Promise<unknown>;
+    /** Download the table as it stands as a file. Absent: no download button. */
+    onDownload?: () => void | Promise<unknown>;
+    /** Who a person column offers. */
+    people?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    /** Extra controls in the toolbar. */
+    actions?: ReactNode;
+    labels?: Partial<TagTableLabels>;
+    className?: string;
+    testId?: string;
+}
+/**
+ * One editable field value of a tag, by its type: committed on blur or Enter (a checkbox and a
+ * choice at once). A table cell, and a field of a single tag's form (`TagDetail`).
+ */
+export declare function TagTableCell({ row, column, people, onChange, l, testId, }: {
+    row: TagTableRow;
+    column: TagTableField;
+    people?: TagTableProps['people'];
+    onChange?: TagTableProps['onChangeValue'];
+    l: TagTableLabels;
+    testId: string;
+}): import("react").JSX.Element;
+export declare function TagTable({ table, isLoading, onChangeValue, onAddRow, onChangeColumns, onOpenDocument, onOpenFact, onOpenThread, onOpenRow, onExport, onDownload, people, actions, labels, className, testId, }: TagTableProps): import("react").JSX.Element;

package/dist/tags/TagsNav.d.ts

@@ -1,7 +1,7 @@
 /**
  * The side navigation of a Tags page: the workspace's tags grouped by kind (labels, annotations,
  * issues, people, organisations, searches), each group with its count, each tag with how much
- * carries it, and nested tags (an issue list's issues) under their parent. A group heading selects
+ * carries it, and nested tags (a label's sub-labels) under their parent. A group heading selects
  * the whole kind; a tag selects that tag. Data-free: the host passes the groups.
  */
 import { type ReactNode } from 'react';
@@ -12,7 +12,7 @@ export interface TagsNavItem {
     count?: number;
     /** A swatch colour (any CSS colour). */
     color?: string;
-    /** Nested tags (e.g. an issue list's issues). */
+    /** Nested tags (e.g. a label's sub-labels). */
     children?: TagsNavItem[];
 }
 export interface TagsNavGroup {

package/dist/tags/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * Tags: a set of tags as an editable matrix with their evidence (`TagMatrix`), one tag in full
- * (`TagDetail`), and the kind-grouped navigation of a Tags page (`TagsNav`).
+ * Tags: a table of tags with their kind's fields as columns and their evidence (`TagTable`, its
+ * columns edited with `TagColumnsEditor`), one tag in full (`TagDetail`), and the kind-grouped
+ * navigation of a Tags page (`TagsNav`).
  */
-export { TagMatrix, TagMatrixCell, DEFAULT_TAG_MATRIX_LABELS, type TagMatrixProps, type TagMatrixLabels, } from './TagMatrix';
+export { TagTable, TagTableCell, DEFAULT_TAG_TABLE_LABELS, type TagTableProps, type TagTableLabels, } from './TagTable';
+export { TagColumnsEditor, DEFAULT_TAG_COLUMNS_EDITOR_LABELS, type TagColumnsEditorProps, type TagColumnsEditorLabels, } from './TagColumnsEditor';
 export { TagDetail, DEFAULT_TAG_DETAIL_LABELS, type TagDetailProps, type TagDetailLabels, } from './TagDetail';
 export { TagsNav, DEFAULT_TAGS_NAV_LABELS, type TagsNavProps, type TagsNavLabels, type TagsNavGroup, type TagsNavItem, type TagsNavSelection, } from './TagsNav';
-export { tagMatrixColumns, tagMatrixMarkdown, cellValue, rowFieldId, cellText, parseCell, isGap, type TagMatrixData, type TagMatrixRowData, type TagMatrixField, type TagMatrixFieldType, type TagMatrixMarkdownOptions, } from './tagMatrixModel';
-export { tagMatrixDocx, tagMatrixDocumentXml, DEFAULT_TAG_MATRIX_DOCX_LABELS, TAG_MATRIX_DOCX_LANDSCAPE_AFTER, type TagMatrixDocxLabels, type TagMatrixDocxOptions, } from './tagMatrixDocx';
+export { tagTableMarkdown, cellValue, cellText, parseCell, isGap, rowLinks, fieldWrites, type TagTableData, type TagTableRow, type TagTableLinks, type TagTableField, type TagTableFieldType, type TagTableFieldWrite, type TagTableMarkdownOptions, } from './tagTableModel';
+export { tagTableDocx, tagTableDocumentXml, DEFAULT_TAG_TABLE_DOCX_LABELS, TAG_TABLE_DOCX_LANDSCAPE_AFTER, type TagTableDocxLabels, type TagTableDocxOptions, } from './tagTableDocx';

package/dist/tags/{tagMatrixDocx.d.ts → tagTableDocx.d.ts}

@@ -1,15 +1,15 @@
 /**
- * The tag matrix as a Word document: a title, when the snapshot was taken, then one table with a
- * row per item, a column per field, the evidence behind it (linked document names and fact
+ * A table of tags as a Word document: a title, when the snapshot was taken, then one table with a
+ * row per tag, a column per field of its kind, the evidence behind it (linked document names and fact
  * excerpts) and its gaps. Written straight as WordprocessingML and zipped with `fflate` (already a
  * dependency, and what `docx/export.ts` uses), so the result opens in the native Word editor and
  * in Word without pulling the editor engine into the tags module.
  */
-import { type TagMatrixData } from './tagMatrixModel';
+import { type TagTableData } from './tagTableModel';
 export declare const DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
 /** More table columns than this (item, fields, evidence, gaps) turn the page to landscape. */
-export declare const TAG_MATRIX_DOCX_LANDSCAPE_AFTER = 6;
-export interface TagMatrixDocxLabels {
+export declare const TAG_TABLE_DOCX_LANDSCAPE_AFTER = 6;
+export interface TagTableDocxLabels {
     /** The row column's heading. */
     row: string;
     evidence: string;
@@ -31,15 +31,15 @@ export interface TagMatrixDocxLabels {
     untitledThread: string;
     empty: string;
 }
-export declare const DEFAULT_TAG_MATRIX_DOCX_LABELS: TagMatrixDocxLabels;
-export interface TagMatrixDocxOptions {
+export declare const DEFAULT_TAG_TABLE_DOCX_LABELS: TagTableDocxLabels;
+export interface TagTableDocxOptions {
     title: string;
     nameOf?: (id: string) => string | undefined;
     /** When the snapshot was taken (ISO); default now. */
     at?: string;
-    labels?: Partial<TagMatrixDocxLabels>;
+    labels?: Partial<TagTableDocxLabels>;
 }
-/** `word/document.xml` for the matrix (exposed for tests and for hosts that assemble their own package). */
-export declare function tagMatrixDocumentXml(matrix: TagMatrixData, options: TagMatrixDocxOptions): string;
-/** The matrix as `.docx` bytes. */
-export declare function tagMatrixDocx(matrix: TagMatrixData, options: TagMatrixDocxOptions): Uint8Array;
+/** `word/document.xml` for the table (exposed for tests and for hosts that assemble their own package). */
+export declare function tagTableDocumentXml(table: TagTableData, options: TagTableDocxOptions): string;
+/** The table as `.docx` bytes. */
+export declare function tagTableDocx(table: TagTableData, options: TagTableDocxOptions): Uint8Array;

package/dist/tags/tagTableModel.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A table of tags as data: the rows are tags (every issue, every person, a label's children) with
+ * their values and links, the columns their kind's fields in the workspace (its issue fields …),
+ * and each row's linked documents, facts and threads its evidence. Pure helpers for `TagTable`: a
+ * row's value, the gaps, and the snapshot as a Markdown document.
+ */
+import type { components } from '@arbidocs/client';
+/** A column: one of the kind's fields. */
+export type TagTableField = components['schemas']['FieldDefinition'];
+export type TagTableFieldType = TagTableField['type'];
+/** A field as written back to the kind (`id` keeps it and its values). */
+export type TagTableFieldWrite = components['schemas']['FieldDefinitionWrite'];
+/** A row: a tag, with its links (`include=links` on the list). */
+export type TagTableRow = components['schemas']['TagResponse'];
+export type TagTableLinks = components['schemas']['TagLinks'];
+/** What a table shows: the kind's fields as columns, and its tags as rows. */
+export interface TagTableData {
+    columns: TagTableField[];
+    rows: TagTableRow[];
+}
+/** A row's links (none when the list was read without them). */
+export declare const rowLinks: (row: TagTableRow) => TagTableLinks;
+/** A row's value for a column (values are keyed by field id). */
+export declare const cellValue: (row: TagTableRow, column: TagTableField) => unknown;
+/** A row with nothing behind it: no linked document, fact or thread. */
+export declare const isGap: (row: TagTableRow) => 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<TagTableField, '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: TagTableFieldType): unknown;
+/** The kind's fields as definitions to write back, every one kept by id. */
+export declare const fieldWrites: (columns: readonly TagTableField[]) => TagTableFieldWrite[];
+export interface TagTableMarkdownOptions {
+    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 table as a Markdown document: a heading, when it was taken, and one table (a row per tag, a
+ * column per field, then the evidence counts). What a host files or has signed.
+ */
+export declare function tagTableMarkdown(table: TagTableData, options: TagTableMarkdownOptions): string;