@arbidocs/blocks 0.4.73 → 0.4.75

package/dist/databases/DatabaseTable.d.ts

@@ -0,0 +1,38 @@
+import { type GridViewProps } from '../files/GridView';
+import { type DatabaseColumnLabels } from './databaseColumns';
+import type { DatabaseColumnView, DatabaseRowView } from './column-types';
+export interface DatabaseTableLabels {
+    newRow: string;
+    emptyTitle: string;
+    emptyMessage: string;
+    noColumnsTitle: string;
+    noColumnsMessage: string;
+    noMatches: string;
+}
+export declare const DEFAULT_DATABASE_TABLE_LABELS: DatabaseTableLabels;
+export interface DatabaseTableProps {
+    columns: DatabaseColumnView[];
+    rows: DatabaseRowView[];
+    /** An edited cell: the value is already in the API's form (`null` empties the cell). */
+    onCellChange?: (row: DatabaseRowView, columnId: string, value: unknown) => void;
+    onAddRow?: () => void;
+    onAddColumn?: () => void;
+    onEditColumn?: (column: DatabaseColumnView) => void;
+    /** Ticked rows (for a bulk delete). With it, rows show a checkbox. */
+    onSelectionChange?: (rows: DatabaseRowView[]) => void;
+    selected?: DatabaseRowView[];
+    /** Read-only: a database of another (public) workspace. */
+    readOnly?: boolean;
+    /** Rows are filtered by a search: an empty result says so instead of "no rows yet". */
+    isFiltered?: boolean;
+    isLoading?: boolean;
+    locale?: string;
+    /** Saved column state key (AG Grid persists by it): one per database. */
+    gridId?: string;
+    height?: GridViewProps<DatabaseRowView>['height'];
+    labels?: Partial<DatabaseTableLabels>;
+    columnLabels?: Partial<DatabaseColumnLabels>;
+    gridProps?: Partial<Omit<GridViewProps<DatabaseRowView>, 'items' | 'columnDefs' | 'getItemId'>>;
+    testId?: string;
+}
+export declare function DatabaseTable({ columns, rows, onCellChange, onAddRow, onAddColumn, onEditColumn, onSelectionChange, selected, readOnly, isFiltered, isLoading, locale, gridId, height, labels, columnLabels, gridProps, testId, }: DatabaseTableProps): import("react").JSX.Element;

package/dist/databases/DatabaseToolbar.d.ts

@@ -0,0 +1,38 @@
+export type DatabaseExportFormat = 'csv' | 'xlsx';
+export interface DatabaseToolbarLabels {
+    back: string;
+    rename: string;
+    rows: (count: number) => string;
+    showing: (shown: number, total: number) => string;
+    search: string;
+    deleteSelected: (count: number) => string;
+    more: string;
+    importRows: string;
+    exportXlsx: string;
+    exportCsv: string;
+    deleteDatabase: string;
+    readOnly: string;
+}
+export declare const DEFAULT_DATABASE_TOOLBAR_LABELS: DatabaseToolbarLabels;
+export interface DatabaseToolbarProps {
+    name: string;
+    description?: string | null;
+    /** Rows matching the search (all rows without one). */
+    total: number;
+    /** Rows loaded into the grid, when fewer than `total`. */
+    shown?: number;
+    search: string;
+    onSearchChange: (text: string) => void;
+    onBack?: () => void;
+    onRename?: (name: string) => void;
+    selectedCount?: number;
+    onDeleteSelected?: () => void;
+    /** Append rows from a .csv / .xlsx file. */
+    onImportRows?: (file: File) => void;
+    onExport?: (format: DatabaseExportFormat) => void;
+    /** Delete the whole database (the host confirms first). */
+    onDeleteDatabase?: () => void;
+    readOnly?: boolean;
+    labels?: Partial<DatabaseToolbarLabels>;
+}
+export declare function DatabaseToolbar({ name, description, total, shown, search, onSearchChange, onBack, onRename, selectedCount, onDeleteSelected, onImportRows, onExport, onDeleteDatabase, readOnly, labels, }: DatabaseToolbarProps): import("react").JSX.Element;

package/dist/databases/NewDatabaseDialog.d.ts

@@ -0,0 +1,25 @@
+export interface NewDatabaseDialogLabels {
+    title: string;
+    description: string;
+    name: string;
+    namePlaceholder: string;
+    about: string;
+    aboutPlaceholder: string;
+    cancel: string;
+    create: string;
+    creating: string;
+}
+export declare const DEFAULT_NEW_DATABASE_DIALOG_LABELS: NewDatabaseDialogLabels;
+export interface NewDatabaseDraft {
+    name: string;
+    description: string | null;
+}
+export interface NewDatabaseDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreate: (draft: NewDatabaseDraft) => void;
+    isCreating?: boolean;
+    error?: string | null;
+    labels?: Partial<NewDatabaseDialogLabels>;
+}
+export declare function NewDatabaseDialog({ open, onOpenChange, onCreate, isCreating, error, labels, }: NewDatabaseDialogProps): import("react").JSX.Element;

package/dist/databases/SelectCellEditor.d.ts

@@ -0,0 +1,6 @@
+import type { CustomCellEditorProps } from 'ag-grid-react';
+export interface SelectCellEditorParams {
+    options: string[];
+    clearLabel?: string;
+}
+export declare function SelectCellEditor(props: CustomCellEditorProps & SelectCellEditorParams): import("react").JSX.Element;

package/dist/databases/SelectChip.d.ts

@@ -0,0 +1,4 @@
+/** A select option as a coloured chip (the same colour wherever the option appears). */
+export declare function SelectChip({ value }: {
+    value: string;
+}): import("react").JSX.Element;

package/dist/databases/column-types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Databases: the shapes the blocks read, and the per-type rules for showing and editing a cell.
+ *
+ * A database is a user-defined table (a client database, billing records). Its columns are typed:
+ * `text`, `number`, `date`, `checkbox` or `select`. The server checks and normalises every cell
+ * (dates arrive as ISO `YYYY-MM-DD` or a full timestamp, numbers as numbers, a select as one of its
+ * options), so the blocks only format for display and turn an editor's value into what the API takes.
+ */
+export type DatabaseColumnType = 'text' | 'number' | 'date' | 'checkbox' | 'select';
+/** Every type, in the order a type picker lists them. */
+export declare const DATABASE_COLUMN_TYPES: DatabaseColumnType[];
+/** A column as the blocks read it (the API's `DatabaseColumn`). */
+export interface DatabaseColumnView {
+    id: string;
+    name: string;
+    type: DatabaseColumnType;
+    options?: string[] | null;
+}
+/** A row as the blocks read it: cell values keyed by column id; an empty cell is absent. */
+export interface DatabaseRowView {
+    id: string;
+    values: Record<string, unknown>;
+}
+/** A database as a list shows it (the API's `DatabaseRead`). */
+export interface DatabaseSummaryView {
+    id: string;
+    name: string;
+    description?: string | null;
+    columns: DatabaseColumnView[];
+    row_count: number;
+    /** False for a database of another (public) workspace: read here, edited in its own workspace. */
+    editable: boolean;
+    updated_at?: string | null;
+}
+export interface DatabaseColumnTypeLabels {
+    text: string;
+    number: string;
+    date: string;
+    checkbox: string;
+    select: string;
+}
+export declare const DEFAULT_DATABASE_COLUMN_TYPE_LABELS: DatabaseColumnTypeLabels;
+export declare function optionTone(option: string): string;
+/**
+ * A stored date for display. A bare `YYYY-MM-DD` is a calendar day: it is shown from its own
+ * components, never through a time zone (which would move it a day for viewers west of UTC).
+ */
+export declare function formatDateValue(value: string, locale?: string): string;
+export declare function formatNumberValue(value: number, locale?: string): string;
+/** A cell as text: what a cell shows, what search and copy see. Checkboxes read as Yes/No. */
+export declare function formatCell(value: unknown, type: DatabaseColumnType, locale?: string): string;
+/**
+ * An editor's value as the API takes it. Empty becomes `null` (which empties the cell); everything
+ * else goes as typed and the server checks it, so a bad value comes back as a 422 naming the column.
+ */
+export declare function toApiValue(value: unknown, type: DatabaseColumnType): unknown;
+/** Sort comparator for a column's stored values: empty cells last, then by type. */
+export declare function compareCells(a: unknown, b: unknown, type: DatabaseColumnType): number;

package/dist/databases/databaseColumns.d.ts

@@ -0,0 +1,28 @@
+import type { ColDef } from 'ag-grid-community';
+import { Type } from 'lucide-react';
+import { type DatabaseColumnType, type DatabaseColumnView, type DatabaseRowView } from './column-types';
+import { SelectChip } from './SelectChip';
+export { SelectChip };
+export interface DatabaseColumnLabels {
+    addColumn: string;
+    columnSettings: (name: string) => string;
+}
+export declare const DEFAULT_DATABASE_COLUMN_LABELS: DatabaseColumnLabels;
+/** colId of the trailing "add a column" column (never a database column id). */
+export declare const ADD_COLUMN_COL_ID = "__add_column";
+export declare const COLUMN_TYPE_ICONS: Record<DatabaseColumnType, typeof Type>;
+export interface DatabaseColumnOptions {
+    /** No editing, no column settings, no add-column button (a database of another workspace). */
+    readOnly?: boolean;
+    /** Open a column's settings (rename, options, delete). */
+    onEditColumn?: (column: DatabaseColumnView) => void;
+    /** Add a column (the trailing "+" header). */
+    onAddColumn?: () => void;
+    /** Locale for numbers and dates. */
+    locale?: string;
+    labels?: Partial<DatabaseColumnLabels>;
+}
+/** Wide enough for the type's values and for the header (icon, name, settings button). */
+export declare function columnWidth(column: DatabaseColumnView): number;
+/** One grid column per database column, then the "add a column" column (unless read-only). */
+export declare function createDatabaseColumns(columns: DatabaseColumnView[], options?: DatabaseColumnOptions): ColDef<DatabaseRowView>[];