@mechane-ai/ui 0.2.2 → 0.3.0

package/dist/packages/charts/src/distribution/ranked-bars.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { ChartSelection } from '../chart-frame.tsx';
+import type { ChartTone } from '../chart-theme.ts';
+import type { NumericDomain } from './distribution-input.ts';
+export type RankedBarDatum = {
+    readonly id: string;
+    readonly label: string;
+    readonly rank?: string;
+    readonly value: number | null;
+    readonly tone?: ChartTone;
+};
+export type RankedBarsProps = {
+    readonly title: string;
+    readonly description?: string;
+    readonly items: ReadonlyArray<RankedBarDatum>;
+    readonly domain: NumericDomain;
+    readonly valueLabel: string;
+    readonly formatValue: (value: number) => string;
+    readonly selection?: ChartSelection;
+    readonly emptyLabel?: string;
+};
+export declare function RankedBars({ title, description, items, domain, valueLabel, formatValue, selection, emptyLabel, }: RankedBarsProps): ReactNode;

package/dist/packages/charts/src/graph/index.d.ts

@@ -0,0 +1,2 @@
+export { RelationGraph, MAX_RELATION_NODES, MAX_RELATION_EDGES, MAX_RELATION_GROUPS, MAX_RELATION_DIMENSION, } from './relation-graph.tsx';
+export type { RelationGraphProps, RelationNode, RelationEdge, RelationGroup } from './relation-graph.tsx';

package/dist/packages/charts/src/graph/relation-graph.d.ts

@@ -0,0 +1,45 @@
+import type { ReactNode } from 'react';
+import type { ChartSelection } from '../chart-frame.tsx';
+import type { ChartTone } from '../chart-theme.ts';
+export type RelationNode = {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string | undefined;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly tone: ChartTone;
+};
+export type RelationEdge = {
+    readonly id: string;
+    readonly sourceId: string;
+    readonly targetId: string;
+    readonly label: string;
+    readonly direction: 'directed' | 'undirected';
+};
+export type RelationGroup = {
+    readonly id: string;
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly nodeIds: ReadonlyArray<string>;
+};
+export type RelationGraphProps = {
+    readonly title: string;
+    readonly description: string;
+    readonly nodes: ReadonlyArray<RelationNode>;
+    readonly edges: ReadonlyArray<RelationEdge>;
+    readonly groups?: ReadonlyArray<RelationGroup> | undefined;
+    readonly width: number;
+    readonly height: number;
+    readonly selection?: ChartSelection | undefined;
+    readonly emptyLabel: string;
+};
+export declare const MAX_RELATION_NODES = 256;
+export declare const MAX_RELATION_EDGES = 1024;
+export declare const MAX_RELATION_GROUPS = 256;
+export declare const MAX_RELATION_DIMENSION = 8192;
+export declare function RelationGraph({ title, description, nodes, edges, groups, width, height, selection, emptyLabel, }: RelationGraphProps): ReactNode;

package/dist/packages/charts/src/index.d.ts

@@ -0,0 +1,13 @@
+export { Waterfall } from './waterfall.tsx';
+export type { WaterfallItem } from './waterfall.tsx';
+export { ChartFrame, ChartLegend } from './chart-frame.tsx';
+export type { ChartFrameProps, ChartLegendProps, ChartLegendItem, ChartSelection } from './chart-frame.tsx';
+export type { ChartTone } from './chart-theme.ts';
+export { LineChart, AreaChart, Sparkline, SmallMultiples, BreakdownBar, BarChart, Treemap } from './cartesian/index.ts';
+export type { TimeSeriesPoint, TimeSeries, TimeSeriesMarker, TimeSeriesChartProps, AreaChartProps, SmallMultiplesProps, SparklineProps, BreakdownItem, BreakdownBarProps, BarSeries, BarChartProps, TreemapProps, } from './cartesian/index.ts';
+export { Histogram, ECDF, IntervalPlot, RankedBars } from './distribution/index.ts';
+export type { HistogramBin, HistogramProps, ECDFPoint, ECDFProps, IntervalDatum, IntervalPlotProps, RankedBarDatum, RankedBarsProps, } from './distribution/index.ts';
+export { ColorLegend, Matrix, TokenHeatmap, ScatterPlot } from './matrix/index.ts';
+export type { ColorLegendProps, HeatmapPalette, HeatmapScale, MatrixProps, MatrixAxisItem, MatrixCell, TokenHeatmapProps, HeatmapToken, ScatterPlotProps, ScatterPoint, ScatterRange, ScatterRangeSelection, } from './matrix/index.ts';
+export { RelationGraph } from './graph/index.ts';
+export type { RelationGraphProps, RelationNode, RelationEdge, RelationGroup } from './graph/index.ts';

package/dist/packages/charts/src/matrix/color-legend.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import type { HeatmapScale } from './heatmap-scale.ts';
+export type ColorLegendProps = HeatmapScale & {
+    readonly label: string;
+    readonly formatValue: (value: number) => string;
+};
+export declare function ColorLegend({ label, domain, palette, formatValue }: ColorLegendProps): ReactNode;

package/dist/packages/charts/src/matrix/heatmap-scale.d.ts

@@ -0,0 +1,8 @@
+export type HeatmapPalette = 'sequential' | 'diverging';
+export type HeatmapScale = {
+    readonly domain: readonly [number, number];
+    readonly palette: HeatmapPalette;
+};
+export declare function heatmapScaleProblem({ domain, palette }: HeatmapScale): string | null;
+export declare function isHeatmapValueInDomain(value: number, domain: readonly [number, number]): boolean;
+export declare function heatmapColor(value: number, { domain, palette }: HeatmapScale): string;

package/dist/packages/charts/src/matrix/index.d.ts

@@ -0,0 +1,9 @@
+export { ColorLegend } from './color-legend.tsx';
+export type { ColorLegendProps } from './color-legend.tsx';
+export type { HeatmapPalette, HeatmapScale } from './heatmap-scale.ts';
+export { Matrix, MAX_MATRIX_CELLS } from './matrix.tsx';
+export type { MatrixProps, MatrixAxisItem, MatrixCell } from './matrix.tsx';
+export { TokenHeatmap, MAX_HEATMAP_TOKENS } from './token-heatmap.tsx';
+export type { TokenHeatmapProps, HeatmapToken } from './token-heatmap.tsx';
+export { ScatterPlot, MAX_SCATTER_POINTS } from './scatter-plot.tsx';
+export type { ScatterPlotProps, ScatterPoint, ScatterRange, ScatterRangeSelection } from './scatter-plot.tsx';

package/dist/packages/charts/src/matrix/matrix.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+import type { ChartSelection } from '../chart-frame.tsx';
+import type { HeatmapScale } from './heatmap-scale.ts';
+export type MatrixAxisItem = {
+    readonly id: string;
+    readonly label: string;
+};
+export type MatrixCell = {
+    readonly id: string;
+    readonly rowId: string;
+    readonly columnId: string;
+} & ({
+    readonly kind: 'value';
+    readonly value: number;
+} | {
+    readonly kind: 'masked';
+    readonly reason: string;
+} | {
+    readonly kind: 'missing';
+    readonly reason: string;
+});
+export type MatrixProps = HeatmapScale & {
+    readonly title: string;
+    readonly description: string;
+    readonly rows: ReadonlyArray<MatrixAxisItem>;
+    readonly columns: ReadonlyArray<MatrixAxisItem>;
+    readonly cells: ReadonlyArray<MatrixCell>;
+    readonly valueLabel: string;
+    readonly formatValue: (value: number) => string;
+    readonly selection?: ChartSelection;
+    readonly emptyLabel: string;
+};
+export declare const MAX_MATRIX_CELLS = 4096;
+export declare function Matrix({ title, description, rows, columns, cells, domain, palette, valueLabel, formatValue, selection, emptyLabel, }: MatrixProps): ReactNode;

package/dist/packages/charts/src/matrix/scatter-plot.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+import type { ChartSelection } from '../chart-frame.tsx';
+import type { ChartTone } from '../chart-theme.ts';
+export type ScatterPoint = {
+    readonly id: string;
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+    readonly tone: ChartTone;
+};
+export type ScatterRange = {
+    readonly x: readonly [number, number];
+    readonly y: readonly [number, number];
+};
+export type ScatterRangeSelection = {
+    readonly value: ScatterRange | null;
+    readonly onChange: (range: ScatterRange | null) => void;
+    readonly xStep: number;
+    readonly yStep: number;
+    readonly locale: string;
+};
+export type ScatterPlotProps = {
+    readonly title: string;
+    readonly description: string;
+    readonly points: ReadonlyArray<ScatterPoint>;
+    readonly xDomain: readonly [number, number];
+    readonly yDomain: readonly [number, number];
+    readonly xLabel: string;
+    readonly yLabel: string;
+    readonly formatX: (value: number) => string;
+    readonly formatY: (value: number) => string;
+    readonly selection?: ChartSelection | undefined;
+    readonly rangeSelection?: ScatterRangeSelection | undefined;
+    readonly emptyLabel: string;
+};
+export declare const MAX_SCATTER_POINTS = 1000;
+export declare function ScatterPlot(props: ScatterPlotProps): ReactNode;

package/dist/packages/charts/src/matrix/token-heatmap.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { ChartSelection } from '../chart-frame.tsx';
+import type { HeatmapScale } from './heatmap-scale.ts';
+export type HeatmapToken = {
+    readonly id: string;
+    readonly index: number;
+    readonly text: string;
+    readonly score: number | null;
+};
+export type TokenHeatmapProps = HeatmapScale & {
+    readonly title: string;
+    readonly description: string;
+    readonly tokens: ReadonlyArray<HeatmapToken>;
+    readonly valueLabel: string;
+    readonly formatValue: (value: number) => string;
+    readonly selection?: ChartSelection;
+    readonly emptyLabel: string;
+};
+export declare const MAX_HEATMAP_TOKENS = 2048;
+export declare function TokenHeatmap({ title, description, tokens, domain, palette, valueLabel, formatValue, selection, emptyLabel, }: TokenHeatmapProps): ReactNode;

package/dist/packages/charts/src/plot-width.d.ts

@@ -0,0 +1,5 @@
+export declare function usePlotWidth(): {
+    ref: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
+    width: number;
+    element: HTMLDivElement | null;
+};

package/dist/packages/collections/src/calendar.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+export type CalendarDate = {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+};
+export type CalendarRange = {
+    readonly from: CalendarDate;
+    readonly to?: CalendarDate | undefined;
+};
+export type CalendarEnvironment = {
+    readonly locale: string;
+    readonly timeZone: string;
+    readonly today: CalendarDate;
+    readonly initialMonth: CalendarDate;
+    readonly minimum?: CalendarDate;
+    readonly maximum?: CalendarDate;
+    readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+};
+export type CalendarProps = CalendarEnvironment & {
+    readonly label: string;
+    readonly autoFocus?: boolean;
+} & ({
+    readonly mode: 'single';
+    readonly value: CalendarDate | undefined;
+    readonly onValueChange: (value: CalendarDate | undefined) => void;
+} | {
+    readonly mode: 'range';
+    readonly value: CalendarRange | undefined;
+    readonly onValueChange: (value: CalendarRange | undefined) => void;
+});
+export declare function Calendar(props: CalendarProps): ReactNode;

package/dist/packages/collections/src/collection-controls.d.ts

@@ -0,0 +1,41 @@
+import type { ReactNode } from 'react';
+export type CollectionToolbarProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+    readonly actions?: ReactNode;
+};
+export declare function CollectionToolbar({ label, children, actions }: CollectionToolbarProps): ReactNode;
+export type FilterChip = {
+    readonly id: string;
+    readonly label: string;
+};
+export type FilterChipsProps = {
+    readonly filters: ReadonlyArray<FilterChip>;
+    readonly onRemove: (id: string) => void;
+    readonly label?: string;
+};
+export declare function FilterChips({ filters, onRemove, label }: FilterChipsProps): ReactNode;
+export type ColumnChoice = {
+    readonly id: string;
+    readonly label: string;
+    readonly visible: boolean;
+    readonly required?: boolean;
+};
+export type ColumnControlsProps = {
+    readonly columns: ReadonlyArray<ColumnChoice>;
+    readonly onVisibilityChange: (columnId: string, visible: boolean) => void;
+    readonly label?: string;
+};
+export declare function ColumnControls({ columns, onVisibilityChange, label }: ColumnControlsProps): ReactNode;
+export type CollectionPaginationProps = {
+    readonly description: string;
+    readonly previous: {
+        readonly disabled: boolean;
+        readonly onClick: () => void;
+    };
+    readonly next: {
+        readonly disabled: boolean;
+        readonly onClick: () => void;
+    };
+};
+export declare function CollectionPagination({ description, previous, next }: CollectionPaginationProps): ReactNode;

package/dist/packages/collections/src/command.d.ts

@@ -0,0 +1,37 @@
+import type { ReactElement, ReactNode, RefObject } from 'react';
+export type CommandShortcut = {
+    readonly key: string;
+    readonly mod?: boolean;
+    readonly ctrl?: boolean;
+    readonly alt?: boolean;
+    readonly shift?: boolean;
+    readonly meta?: boolean;
+};
+export type CommandAction = {
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+    readonly shortcut?: CommandShortcut;
+    readonly disabled?: boolean;
+    readonly onSelect: () => void;
+};
+export type CommandShortcutsOptions = {
+    readonly commands: ReadonlyArray<CommandAction>;
+    readonly target: RefObject<HTMLElement | null> | HTMLElement | null;
+    readonly enabled: boolean;
+};
+export declare function useCommandShortcuts({ commands, target, enabled }: CommandShortcutsOptions): void;
+export type ShortcutHintProps = {
+    readonly shortcut: CommandShortcut;
+};
+export declare function ShortcutHint({ shortcut }: ShortcutHintProps): ReactNode;
+export type CommandPaletteProps = {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly title: string;
+    readonly commands: ReadonlyArray<CommandAction>;
+    readonly trigger?: ReactElement;
+    readonly placeholder?: string;
+    readonly empty?: string;
+};
+export declare function CommandPalette({ open, onOpenChange, title, commands, trigger, placeholder, empty, }: CommandPaletteProps): ReactNode;

package/dist/packages/collections/src/data-table.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode } from 'react';
+type ColumnAlignment = 'start' | 'end';
+export type DataTableColumn<Row> = {
+    readonly id: string;
+    readonly label: string;
+    readonly cell: (row: Row) => ReactNode;
+    readonly align?: ColumnAlignment;
+    readonly width?: number;
+    readonly sortable?: boolean;
+};
+export type DataTableSort = {
+    readonly columnId: string;
+    readonly direction: 'ascending' | 'descending';
+};
+export type DataTableWindow = {
+    readonly height: number;
+    readonly estimatedRowHeight?: number;
+};
+type SortProperties<Row> = {
+    readonly columns: ReadonlyArray<DataTableColumn<Row>>;
+    readonly sort: DataTableSort | undefined;
+    readonly onSortChange: (sort: DataTableSort | undefined) => void;
+} | {
+    readonly columns: ReadonlyArray<DataTableColumn<Row> & {
+        readonly sortable?: false;
+    }>;
+    readonly sort?: never;
+    readonly onSortChange?: never;
+};
+type SelectionProperties<Row> = {
+    readonly selectedIds: ReadonlySet<string>;
+    readonly onSelectionChange: (selectedIds: ReadonlySet<string>) => void;
+    readonly selectionLabel: (row: Row) => string;
+};
+type OptionalSelection<Row> = SelectionProperties<Row> | {
+    readonly selectedIds?: never;
+    readonly onSelectionChange?: never;
+    readonly selectionLabel?: never;
+};
+export type DataTableProps<Row> = SortProperties<Row> & OptionalSelection<Row> & {
+    readonly rows: ReadonlyArray<Row>;
+    readonly getRowId: (row: Row) => string;
+    readonly caption: string;
+    readonly empty: string;
+    readonly window?: DataTableWindow;
+    readonly footer?: ReactNode;
+};
+export declare function DataTable<Row extends object>({ rows, columns, getRowId, caption, empty, sort, onSortChange, selectedIds, onSelectionChange, selectionLabel, window, footer, }: DataTableProps<Row>): ReactNode;
+export {};

package/dist/packages/collections/src/date-range-picker.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { CalendarEnvironment, CalendarRange } from './calendar.tsx';
+export type DateRangePreset = {
+    readonly id: string;
+    readonly label: string;
+    readonly value: CalendarRange;
+};
+export type DateRangePickerProps = {
+    readonly label: string;
+    readonly value: CalendarRange | undefined;
+    readonly onValueChange: (value: CalendarRange | undefined) => void;
+    readonly formatValue: (value: CalendarRange) => string;
+    readonly presets?: ReadonlyArray<DateRangePreset>;
+    readonly disabled?: boolean;
+} & CalendarEnvironment;
+export declare function DateRangePicker({ label, value, onValueChange, formatValue, presets, disabled, ...environment }: DateRangePickerProps): ReactNode;

package/dist/packages/collections/src/index.d.ts

@@ -0,0 +1,13 @@
+export { ListFooter } from './list-footer.tsx';
+export { Cell, Table } from './table.tsx';
+export { Inspector, Details } from './inspector.tsx';
+export { DataTable } from './data-table.tsx';
+export type { DataTableColumn, DataTableProps, DataTableSort, DataTableWindow } from './data-table.tsx';
+export { CollectionToolbar, FilterChips, ColumnControls, CollectionPagination } from './collection-controls.tsx';
+export type { CollectionToolbarProps, FilterChip, FilterChipsProps, ColumnChoice, ColumnControlsProps, CollectionPaginationProps, } from './collection-controls.tsx';
+export { Calendar } from './calendar.tsx';
+export type { CalendarDate, CalendarRange, CalendarEnvironment, CalendarProps } from './calendar.tsx';
+export { DateRangePicker } from './date-range-picker.tsx';
+export type { DateRangePreset, DateRangePickerProps } from './date-range-picker.tsx';
+export { CommandPalette, ShortcutHint, useCommandShortcuts } from './command.tsx';
+export type { CommandAction, CommandPaletteProps, CommandShortcut, CommandShortcutsOptions, ShortcutHintProps, } from './command.tsx';

package/dist/packages/content/src/code/code-block.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+export type CodeAnnotation = {
+    readonly line: number;
+    readonly content: ReactNode;
+};
+export type CodeSelection = {
+    readonly start: number;
+    readonly end?: number;
+};
+export type CodeBlockProps = {
+    readonly code: string;
+    readonly language?: string | undefined;
+    readonly filename?: string | undefined;
+    readonly streaming?: boolean;
+    readonly wrap?: boolean;
+    readonly lineNumbers?: boolean;
+    readonly selectedLines?: CodeSelection;
+    readonly annotations?: ReadonlyArray<CodeAnnotation>;
+    readonly maxHeight?: number;
+    readonly maxLines?: number;
+};
+export declare function CodeBlock({ code, language, filename, streaming, wrap, lineNumbers, selectedLines, annotations, maxHeight, maxLines, }: CodeBlockProps): ReactNode;

package/dist/packages/content/src/code/index.d.ts

@@ -0,0 +1,2 @@
+export { CodeBlock } from './code-block.tsx';
+export type { CodeAnnotation, CodeBlockProps, CodeSelection } from './code-block.tsx';

package/dist/packages/content/src/code/use-highlighted-code.d.ts

@@ -0,0 +1,9 @@
+import type { ThemedToken } from '@pierre/highlights';
+type HighlightResult = {
+    readonly code: string;
+    readonly language: string;
+    readonly lines: ReadonlyArray<ReadonlyArray<ThemedToken>>;
+    readonly hasFailed: boolean;
+};
+export declare function useHighlightedCode(code: string, language: string): HighlightResult | undefined;
+export {};

package/dist/packages/content/src/content-link.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export type ContentLinkProps = {
+    readonly href?: string | undefined;
+    readonly children: ReactNode;
+    readonly title?: string | undefined;
+};
+export declare function contentHref(value: string | undefined): string | undefined;
+export declare function ContentLink({ href, children, title }: ContentLinkProps): ReactNode;

package/dist/packages/content/src/diff/diff-source.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+export type DiffFile = {
+    readonly name: string;
+    readonly code: string;
+    readonly language?: string | undefined;
+};
+export type DiffAnnotation = {
+    readonly file: string;
+    readonly side: 'old' | 'new';
+    readonly line: number;
+    readonly content: ReactNode;
+};
+export type DiffSource = {
+    readonly patch: string;
+    readonly before?: never;
+    readonly after?: never;
+} | {
+    readonly patch?: never;
+    readonly before: DiffFile;
+    readonly after: DiffFile | null;
+} | {
+    readonly patch?: never;
+    readonly before: null;
+    readonly after: DiffFile;
+};
+export type DiffViewerProps = DiffSource & {
+    readonly label: string;
+    readonly layout?: 'unified' | 'split';
+    readonly wrap?: boolean;
+    readonly annotations?: ReadonlyArray<DiffAnnotation>;
+    readonly maxHeight?: number;
+};

package/dist/packages/content/src/diff/diff-viewer.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { DiffViewerProps } from './diff-source.ts';
+export declare function DiffViewer(props: DiffViewerProps): ReactNode;

package/dist/packages/content/src/diff/index.d.ts

@@ -0,0 +1,2 @@
+export { DiffViewer } from './diff-viewer.tsx';
+export type { DiffAnnotation, DiffFile, DiffSource, DiffViewerProps } from './diff-source.ts';

package/dist/packages/content/src/diff/pierre-diff.d.ts

@@ -0,0 +1,14 @@
+import type { FileDiffMetadata } from '@pierre/diffs';
+import type { ReactNode } from 'react';
+import type { DiffAnnotation, DiffSource } from './diff-source.ts';
+type PierreDiffProps = {
+    readonly files: ReadonlyArray<FileDiffMetadata>;
+    readonly layout: 'unified' | 'split';
+    readonly wrap: boolean;
+    readonly annotations: ReadonlyArray<DiffAnnotation>;
+    readonly maxHeight: number;
+    readonly label: string;
+};
+export declare function prepareDiff(source: DiffSource): ReadonlyArray<FileDiffMetadata>;
+export declare function PierreDiff({ files, layout, wrap, annotations, maxHeight, label }: PierreDiffProps): ReactNode;
+export {};

package/dist/packages/content/src/index.d.ts

@@ -0,0 +1,10 @@
+export { Markdown } from './markdown.tsx';
+export type { MarkdownProps } from './markdown.tsx';
+export { JsonViewer } from './json-viewer.tsx';
+export type { JsonValue, JsonViewerProps } from './json-viewer.tsx';
+export { LogViewer } from './log-viewer.tsx';
+export type { LogViewerProps } from './log-viewer.tsx';
+export { StackTrace } from './stack-trace.tsx';
+export type { StackFrame, StackTraceProps } from './stack-trace.tsx';
+export { ContentLink } from './content-link.tsx';
+export type { ContentLinkProps } from './content-link.tsx';

package/dist/packages/content/src/json-viewer.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+export type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | {
+    readonly [key: string]: JsonValue;
+};
+export type JsonViewerProps = {
+    readonly value: JsonValue;
+    readonly label: string;
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+};
+export declare function JsonViewer({ value, label, maxDepth, maxEntries }: JsonViewerProps): ReactNode;

package/dist/packages/content/src/link.d.ts

@@ -0,0 +1,2 @@
+export { ContentLink } from './content-link.tsx';
+export type { ContentLinkProps } from './content-link.tsx';

package/dist/packages/content/src/log-viewer.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export type LogViewerProps = {
+    readonly output: string;
+    readonly label: string;
+    readonly maxLines?: number;
+    readonly maxHeight?: number;
+    readonly isRunning?: boolean;
+};
+export declare function LogViewer({ output, label, maxLines, maxHeight, isRunning, }: LogViewerProps): ReactNode;

package/dist/packages/content/src/markdown.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export type MarkdownProps = {
+    readonly children: string;
+    readonly streaming?: boolean;
+    readonly label?: string;
+};
+export declare function Markdown({ children, streaming, label }: MarkdownProps): ReactNode;

package/dist/packages/content/src/pierre-theme.d.ts

@@ -0,0 +1,36 @@
+export declare const highlightTheme: {
+    readonly name: 'Mechane';
+    readonly appearance: 'light';
+    readonly cssVariables: {
+        readonly prefix: '--mechane-syntax-';
+        readonly defaults: {
+            readonly foreground: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly background: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly keyword: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly string: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly comment: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly number: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly type: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly punctuation: import("@stylexjs/stylex").StyleXVar<string>;
+        };
+    };
+    readonly style: {
+        readonly 'editor.background': 'background';
+        readonly 'editor.foreground': 'foreground';
+        readonly syntax: {
+            readonly keyword: {
+                readonly color: 'keyword';
+                readonly font_weight: 600;
+            };
+            readonly string: 'string';
+            readonly comment: 'comment';
+            readonly number: 'number';
+            readonly type: 'type';
+            readonly function: 'foreground';
+            readonly operator: 'punctuation';
+            readonly punctuation: 'punctuation';
+        };
+    };
+};
+export declare const pierreCSS: string;
+export declare const treeCSS: string;

package/dist/packages/content/src/stack-trace.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+export type StackFrame = {
+    readonly id: string;
+    readonly name: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly href?: string;
+    readonly code?: string;
+    readonly language?: string;
+};
+export type StackTraceProps = {
+    readonly message: string;
+    readonly frames: ReadonlyArray<StackFrame>;
+};
+export declare function StackTrace({ message, frames }: StackTraceProps): ReactNode;

package/dist/packages/content/src/tree/file-tree-types.d.ts

@@ -0,0 +1,12 @@
+export type FileStatus = {
+    readonly path: string;
+    readonly status: 'added' | 'deleted' | 'ignored' | 'modified' | 'renamed' | 'untracked';
+};
+export type FileTreeProps = {
+    readonly paths: ReadonlyArray<string>;
+    readonly label: string;
+    readonly selectedPaths: ReadonlyArray<string>;
+    readonly onSelectedPathsChange: (paths: ReadonlyArray<string>) => void;
+    readonly statuses?: ReadonlyArray<FileStatus>;
+    readonly height?: number;
+};

package/dist/packages/content/src/tree/file-tree.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { FileTreeProps } from './file-tree-types.ts';
+export declare function FileTree(props: FileTreeProps): ReactNode;

package/dist/packages/content/src/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { FileTree } from './file-tree.tsx';
+export type { FileStatus, FileTreeProps } from './file-tree-types.ts';