@amsterdamdatalabs/enact-design-system 0.1.10 → 0.1.19

package/dist/components/ai/VoiceControls/VoiceControls.d.ts

@@ -0,0 +1,34 @@
+export interface VoiceControlsProps {
+    /** Disables controls and shows a busy state on the stop action. */
+    busy?: boolean;
+    /** Additional class name applied to the panel. */
+    className?: string;
+    /** Accessible label for the control group. Default: "Voice controls". */
+    label?: string;
+    /** Indicates that microphone input is currently muted. */
+    muted?: boolean;
+    /** Accessible label for the mute action. Default: "Mute microphone". */
+    muteLabel?: string;
+    /** Called when the voice session should stop. */
+    onStop?: () => void;
+    /** Called when the mute state should be toggled. */
+    onToggleMute?: () => void;
+    /** Indicates that incoming voice output is active. */
+    speaking?: boolean;
+    /** Accessible label for the stop action. Default: "Stop voice". */
+    stopLabel?: string;
+    /** Accessible label for the unmute action. Default: "Unmute microphone". */
+    unmuteLabel?: string;
+    /** Normalized microphone volume level, from 0 to 1. */
+    volume?: number;
+    /** Optional accessible description for the audio-level visualization. */
+    volumeLabel?: string;
+}
+/**
+ * Controlled visual surface for an active voice session.
+ *
+ * The owning application supplies normalized volume/state and intent callbacks;
+ * audio capture, voice lifecycle, translations, and persistence remain outside
+ * the design system.
+ */
+export declare function VoiceControls({ busy, className, label, muteLabel, muted, onStop, onToggleMute, speaking, stopLabel, unmuteLabel, volume, volumeLabel, }: VoiceControlsProps): import("react").JSX.Element;

package/dist/components/ai/VoiceControls/index.d.ts

@@ -0,0 +1 @@
+export { VoiceControls, type VoiceControlsProps } from "./VoiceControls";

package/dist/components/ai/WorkspaceComposerView/WorkspaceComposerView.d.ts

@@ -0,0 +1,37 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface WorkspaceComposerQueueItem {
+    editLabel: string;
+    id: string;
+    onEdit: () => void;
+    onSend: () => void;
+    sendLabel: string;
+    text: string;
+}
+export interface WorkspaceComposerViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Controlled attachment pills or other composer-adjacent content. */
+    attachmentSlot?: ReactNode;
+    /** Caller-owned autocomplete overlay anchored to the input region. */
+    autocompleteSlot?: ReactNode;
+    /** Caller-owned error content announced above the composer surface. */
+    errorSlot?: ReactNode;
+    /** Caller-owned footer content below the composer surface. */
+    footerSlot?: ReactNode;
+    /** The normalized input and toolbar visual supplied by the application. */
+    inputSlot: ReactNode;
+    /** Caller-owned lightbox or modal content associated with attachments. */
+    lightboxSlot?: ReactNode;
+    /** Prevents interaction with the composed surface while an app-owned action runs. */
+    locked?: boolean;
+    /** Caller-owned picker overlay, such as a GitHub issue search. */
+    pickerSlot?: ReactNode;
+    /** Controlled queued-message rows and their app-owned edit/send intents. */
+    queueItems?: readonly WorkspaceComposerQueueItem[];
+    ref?: Ref<HTMLDivElement>;
+    testId?: string;
+}
+/**
+ * Controlled web composer frame. The design system owns the frame, queue,
+ * attachment, input-region, error, and footer presentation; applications own
+ * editing, uploads, autocomplete, session state, and every mutation.
+ */
+export declare function WorkspaceComposerView({ attachmentSlot, autocompleteSlot, className, errorSlot, footerSlot, inputSlot, lightboxSlot, locked, pickerSlot, queueItems, ref, testId, ...rest }: WorkspaceComposerViewProps): import("react").JSX.Element;

package/dist/components/ai/WorkspaceComposerView/index.d.ts

@@ -0,0 +1 @@
+export { type WorkspaceComposerQueueItem, WorkspaceComposerView, type WorkspaceComposerViewProps, } from "./WorkspaceComposerView";

package/dist/components/ai/WorkspaceDraftComposerView/WorkspaceDraftComposerView.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface WorkspaceDraftComposerViewProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    /** The controlled composer input surface. */
+    composer: ReactNode;
+    /** Display-ready configuration content shown before submission. */
+    configuration?: ReactNode;
+    /** Display-ready validation or submission error. */
+    error?: ReactNode;
+    /** Optional controlled import action placed above the composer. */
+    importAction?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    /** Application-owned agent stream content. */
+    stream?: ReactNode;
+    /** Selects stream content over the configuration surface. */
+    submitting?: boolean;
+}
+/**
+ * Controlled workspace draft-composer frame. The app retains agent creation,
+ * attachments, draft persistence, input focus, imports, and runtime effects;
+ * DS owns the web canvas, configuration, error, import, and composer layout.
+ */
+export declare function WorkspaceDraftComposerView({ className, composer, configuration, error, importAction, ref, stream, submitting, ...rest }: WorkspaceDraftComposerViewProps): import("react").JSX.Element;

package/dist/components/ai/WorkspaceDraftComposerView/index.d.ts

@@ -0,0 +1 @@
+export { WorkspaceDraftComposerView, type WorkspaceDraftComposerViewProps, } from "./WorkspaceDraftComposerView";

package/dist/components/content/ArtifactCard/ArtifactCard.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface ArtifactCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** The artifact body rendered in the card. */
+    children: ReactNode;
+    /** When provided, renders an export Button. */
+    onExport?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    /** The artifact title displayed in the card header. */
+    title: string;
+}
+export declare function ArtifactCard({ title, children, onExport, className, ref, ...rest }: ArtifactCardProps): import("react").JSX.Element;

package/dist/components/content/ArtifactCard/index.d.ts

@@ -0,0 +1 @@
+export { ArtifactCard, type ArtifactCardProps } from "./ArtifactCard";

package/dist/components/content/ArtifactPreviewFrame/ArtifactPreviewFrame.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ArtifactPreviewFrameKind = "audio" | "code" | "document" | "image" | "video";
+export type ArtifactPreviewFrameState = "empty" | "error" | "loading" | "ready";
+export interface ArtifactPreviewFrameProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Ready content supplied by the consumer's browser/media lifecycle. */
+    children?: ReactNode;
+    /** Display-ready empty state supplied by the consumer. */
+    empty?: ReactNode;
+    /** Display-ready error state supplied by the consumer. */
+    error?: ReactNode;
+    /** Selects the DS-owned media and code surface treatment. */
+    kind?: ArtifactPreviewFrameKind;
+    /** Display-ready loading state supplied by the consumer. */
+    loading?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /** The application-owned preview lifecycle state. */
+    state?: ArtifactPreviewFrameState;
+}
+/**
+ * A controlled asset preview surface. The consumer owns artifact typing, URL
+ * policy, fetching, sandboxing, and browser/media lifecycles; this component
+ * owns the theme-native preview frame and its ready, loading, error, and empty
+ * visual states.
+ */
+export declare function ArtifactPreviewFrame({ children, className, empty, error, kind, loading, ref, state, ...rest }: ArtifactPreviewFrameProps): import("react").JSX.Element;

package/dist/components/content/ArtifactPreviewFrame/index.d.ts

@@ -0,0 +1 @@
+export { ArtifactPreviewFrame, type ArtifactPreviewFrameKind, type ArtifactPreviewFrameProps, type ArtifactPreviewFrameState, } from "./ArtifactPreviewFrame";

package/dist/components/content/CodeBlock/CodeBlock.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLAttributes, Ref } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export interface CodeBlockProps extends HTMLAttributes<HTMLDivElement> {
+    code: string;
+    /** Localized confirmation label. Defaults to the existing English label. */
+    copiedLabel?: string;
+    copyable?: boolean;
+    /** Duration in milliseconds for the copied confirmation. Defaults to 2000. */
+    copyFeedbackDuration?: number;
+    /** Localized copy-control label. Defaults to the existing English label. */
+    copyLabel?: string;
+    fileName?: string;
+    /** Display-ready syntax lines. Parsing and tokenization remain external. */
+    highlightedLines?: readonly SyntaxCodeLine[];
+    language?: string;
+    ref?: Ref<HTMLElement>;
+    showLineNumbers?: boolean;
+    /** One-based line number used when rendering highlighted lines with a gutter. */
+    startLineNumber?: number;
+    wrap?: boolean;
+}
+export declare function CodeBlock({ code, language, showLineNumbers, copyable, copyLabel, copiedLabel, copyFeedbackDuration, wrap, fileName, highlightedLines, startLineNumber, className, ref, ...rest }: CodeBlockProps): import("react").JSX.Element;

package/dist/components/content/CodeBlock/index.d.ts

@@ -0,0 +1,2 @@
+export type { CodeBlockProps } from "./CodeBlock";
+export { CodeBlock } from "./CodeBlock";

package/dist/components/content/ComponentPreview/ComponentPreview.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import type { Align } from "../../layout/shared/scale";
+export interface ComponentPreviewProps {
+    code: string;
+    description?: string;
+    /** Optional anchor id for in-page navigation. */
+    id?: string;
+    preview: ReactNode;
+    /** Cross-axis alignment of preview content. Default: center. */
+    previewAlign?: Align;
+    title: string;
+}
+export declare function ComponentPreview({ id, title, description, preview, code, previewAlign, }: ComponentPreviewProps): import("react").JSX.Element;

package/dist/components/content/ComponentPreview/index.d.ts

@@ -0,0 +1,2 @@
+export type { ComponentPreviewProps } from "./ComponentPreview";
+export { ComponentPreview } from "./ComponentPreview";

package/dist/components/content/DiffStat/DiffStat.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface DiffStatProps extends HTMLAttributes<HTMLSpanElement> {
+    additions: number;
+    compact?: boolean;
+    deletions: number;
+    ref?: Ref<HTMLSpanElement>;
+    showZero?: boolean;
+}
+export declare function DiffStat({ additions, compact, deletions, showZero, className, ref, ...rest }: DiffStatProps): import("react").JSX.Element;

package/dist/components/content/DiffStat/index.d.ts

@@ -0,0 +1 @@
+export { DiffStat, type DiffStatProps } from "./DiffStat";

package/dist/components/content/DiffView/DiffView.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, Ref } from "react";
+import type { DiffHunk } from "./diff";
+export interface DiffViewProps extends HTMLAttributes<HTMLElement> {
+    /** Optional file name shown in the header. */
+    fileName?: string;
+    /** Pre-computed hunks. Provide either `hunks` or `oldText`+`newText`. */
+    hunks?: DiffHunk[];
+    /** Display layout. Defaults to "unified". */
+    mode?: "unified" | "split";
+    /** Target text. Used with `oldText` to auto-compute hunks via LCS. */
+    newText?: string;
+    /** Source text. Used with `newText` to auto-compute hunks via LCS. */
+    oldText?: string;
+    ref?: Ref<HTMLElement>;
+}
+export declare function DiffView({ hunks: hunksProp, oldText, newText, mode, fileName, className, ref, ...rest }: DiffViewProps): import("react").JSX.Element;

package/dist/components/content/DiffView/diff.d.ts

@@ -0,0 +1,20 @@
+export interface DiffLine {
+    content: string;
+    newNo?: number;
+    oldNo?: number;
+    type: "add" | "del" | "context";
+}
+export interface DiffHunk {
+    header?: string;
+    lines: DiffLine[];
+}
+/**
+ * Compute the Longest Common Subsequence of two string arrays.
+ * Returns the common elements in order.
+ */
+export declare function lcs(a: string[], b: string[]): string[];
+/**
+ * Compute diff hunks from plain old/new text strings.
+ * Uses a simple line-level LCS to produce add/del/context DiffLines.
+ */
+export declare function computeHunks(oldText: string, newText: string): DiffHunk[];

package/dist/components/content/DiffView/index.d.ts

@@ -0,0 +1,2 @@
+export { DiffView, type DiffViewProps } from "./DiffView";
+export type { DiffHunk, DiffLine } from "./diff";

package/dist/components/content/DocumentPreviewFrame/DocumentPreviewFrame.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type DocumentPreviewFrameState = "empty" | "error" | "loading" | "ready";
+export interface DocumentPreviewFrameProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    children?: ReactNode;
+    hint?: ReactNode;
+    message?: ReactNode;
+    onRetry?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    retryLabel?: string;
+    sandbox?: string;
+    srcDoc?: string;
+    state?: DocumentPreviewFrameState;
+    title?: string;
+}
+export declare function DocumentPreviewFrame({ children, className, hint, message, onRetry, ref, retryLabel, sandbox, srcDoc, state, title, ...rest }: DocumentPreviewFrameProps): import("react").JSX.Element;

package/dist/components/content/DocumentPreviewFrame/index.d.ts

@@ -0,0 +1 @@
+export { DocumentPreviewFrame, type DocumentPreviewFrameProps, type DocumentPreviewFrameState, } from "./DocumentPreviewFrame";

package/dist/components/content/DocumentViewer/DocumentViewer.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import type { ActivityTimelineItem } from "../../ai/ActivityTimeline/ActivityTimeline";
+import type { SourceCardProps } from "../SourceCard/SourceCard";
+export interface DocumentChapter {
+    id: string;
+    label: string;
+}
+export interface DocumentViewerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    activeChapterId?: string;
+    activity?: ActivityTimelineItem[];
+    body: ReactNode;
+    chapters?: DocumentChapter[];
+    onChapterSelect?: (id: string) => void;
+    ref?: Ref<HTMLDivElement>;
+    sources?: SourceCardProps[];
+    title: string;
+}
+export declare function DocumentViewer({ title, body, chapters, activeChapterId: controlledActiveChapterId, onChapterSelect, activity, sources, className, ref, ...rest }: DocumentViewerProps): import("react").JSX.Element;

package/dist/components/content/DocumentViewer/index.d.ts

@@ -0,0 +1 @@
+export { type DocumentChapter, DocumentViewer, type DocumentViewerProps, } from "./DocumentViewer";

package/dist/components/content/FilePreviewSurface/FilePreviewSurface.d.ts

@@ -0,0 +1,44 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export interface FilePreviewSelectedRange {
+    /** Inclusive one-based source line where the application selection ends. */
+    end: number;
+    /** Inclusive one-based source line where the application selection starts. */
+    start: number;
+}
+interface FilePreviewSurfaceBaseProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    ref?: Ref<HTMLDivElement>;
+}
+export interface FilePreviewCodeSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Reduces source padding for dense file-preview contexts. */
+    compact?: boolean;
+    /** Selects the pre-tokenized source presentation. */
+    kind: "code";
+    /** Pre-tokenized source lines; tokenization and source selection stay external. */
+    lines: readonly SyntaxCodeLine[];
+    /** Optional inclusive, one-based highlighted source range. */
+    selectedRange?: FilePreviewSelectedRange;
+}
+export interface FilePreviewMarkdownSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Adapter-rendered markdown. Parsing, links, and custom render rules stay external. */
+    children: ReactNode;
+    /** Selects the rendered markdown presentation. */
+    kind: "markdown";
+}
+export interface FilePreviewImageSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Accessible image description; omit only for decorative previews. */
+    alt?: string;
+    /** Selects the policy-approved image preview presentation. */
+    kind: "image";
+    /** A consumer-owned, policy-approved image source URL. */
+    src: string;
+}
+/**
+ * A controlled, frameless preview body for file content inside `FileFrame`.
+ * Consumers retain file access, source parsing, URL policy, scrolling policy,
+ * and selection/scroll synchronization. This component owns only the
+ * theme-native code, markdown, and image presentations.
+ */
+export type FilePreviewSurfaceProps = FilePreviewCodeSurfaceProps | FilePreviewMarkdownSurfaceProps | FilePreviewImageSurfaceProps;
+export declare function FilePreviewSurface(props: FilePreviewSurfaceProps): import("react").JSX.Element;
+export {};

package/dist/components/content/FilePreviewSurface/index.d.ts

@@ -0,0 +1,2 @@
+export type { FilePreviewCodeSurfaceProps, FilePreviewImageSurfaceProps, FilePreviewMarkdownSurfaceProps, FilePreviewSelectedRange, FilePreviewSurfaceProps, } from "./FilePreviewSurface";
+export { FilePreviewSurface } from "./FilePreviewSurface";

package/dist/components/content/HighlightedCodeBlock/HighlightedCodeBlock.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLAttributes } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export type HighlightedCodeCopyState = "idle" | "copied";
+export interface HighlightedCodeBlockProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The unparsed source, used when display-ready lines are unavailable. */
+    code: string;
+    /** Localized label announced and shown after the app reports a successful copy. */
+    copiedLabel?: string;
+    /** Hide the copy control while retaining the rest of the presentation. */
+    copyable?: boolean;
+    /** Localized label announced by the copy control in its idle state. */
+    copyLabel?: string;
+    /** Controlled copy feedback state; the DS does not access the clipboard. */
+    copyState?: HighlightedCodeCopyState;
+    /** Display-ready syntax lines. Parsing and caching remain external. */
+    highlightedLines?: readonly SyntaxCodeLine[];
+    /** Optional normalized language label for the presentation toolbar. */
+    language?: string;
+    /** App-owned clipboard action. The DS only invokes this callback. */
+    onCopyCode: () => void;
+}
+export declare function HighlightedCodeBlock({ code, highlightedLines, language, copyLabel, copiedLabel, copyState, onCopyCode, copyable, className, ...rest }: HighlightedCodeBlockProps): import("react").JSX.Element;

package/dist/components/content/HighlightedCodeBlock/index.d.ts

@@ -0,0 +1 @@
+export { HighlightedCodeBlock, type HighlightedCodeBlockProps, type HighlightedCodeCopyState, } from "./HighlightedCodeBlock";

package/dist/components/content/MarkdownRendererView/MarkdownRendererView.d.ts

@@ -0,0 +1,49 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface MarkdownRendererViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Rendered markdown content supplied by the application adapter. */
+    children?: ReactNode;
+    /** Selects the compact presentation used by dense content surfaces. */
+    compact?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+export interface MarkdownRendererDetailsViewProps {
+    children?: ReactNode;
+    expanded: boolean;
+    onExpandedChange: (expanded: boolean) => void;
+    summary: ReactNode;
+}
+export interface MarkdownRendererImageViewProps {
+    alt?: string;
+    fallbackText?: ReactNode;
+    flow?: boolean;
+    height: number;
+    onActivate?: () => void;
+    /** Called when the policy-approved image cannot be decoded or loaded. */
+    onError?: () => void;
+    src: string;
+    width: number;
+}
+export interface MarkdownRendererImageTextRowProps {
+    children?: ReactNode;
+    images: ReactNode;
+}
+export interface MarkdownRendererListItemViewProps {
+    children?: ReactNode;
+    marker: ReactNode;
+}
+/**
+ * Controlled presentation shell for application-owned markdown renderers.
+ *
+ * The application remains responsible for parsing, custom render rules,
+ * links, images, and platform rendering. This component owns only the
+ * reusable DOM boundary and presentation state around those supplied nodes.
+ */
+export declare function MarkdownRendererView({ children, className, compact, ref, ...rest }: MarkdownRendererViewProps): import("react").JSX.Element;
+/** Controlled disclosure shell for application-parsed `<details>` blocks. */
+export declare function MarkdownRendererDetailsView({ children, expanded, onExpandedChange, summary, }: MarkdownRendererDetailsViewProps): import("react").JSX.Element;
+/** Controlled image shell. The application supplies a policy-approved URL and action. */
+export declare function MarkdownRendererImageView({ alt, fallbackText, flow, height, onActivate, onError, src, width, }: MarkdownRendererImageViewProps): import("react").JSX.Element;
+/** Layout shell for policy-approved flow images paired with markdown content. */
+export declare function MarkdownRendererImageTextRow({ children, images, }: MarkdownRendererImageTextRowProps): import("react").JSX.Element;
+/** Structural row used by application-defined ordered and bullet-list rules. */
+export declare function MarkdownRendererListItemView({ children, marker, }: MarkdownRendererListItemViewProps): import("react").JSX.Element;

package/dist/components/content/MarkdownRendererView/index.d.ts

@@ -0,0 +1 @@
+export { MarkdownRendererDetailsView, type MarkdownRendererDetailsViewProps, MarkdownRendererImageTextRow, type MarkdownRendererImageTextRowProps, MarkdownRendererImageView, type MarkdownRendererImageViewProps, MarkdownRendererListItemView, type MarkdownRendererListItemViewProps, MarkdownRendererView, type MarkdownRendererViewProps, } from "./MarkdownRendererView";

package/dist/components/content/MarkdownView/MarkdownView.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MarkdownView — renders a markdown string to React elements using DS
+ * primitives (Heading, Text, CodeBlock). Zero external parser or sanitizer
+ * dependencies. All output is React elements; raw HTML / angle-bracket content
+ * in the source string is passed through as text and escaped by React.
+ *
+ * Supported subset:
+ *   - ATX headings `#`..`######`
+ *   - Paragraphs
+ *   - Bold `**` / `__`
+ *   - Italic `*` / `_`
+ *   - Inline code `` ` ``
+ *   - Links `[text](url)` — external http(s) links open in a new tab
+ *     with `rel="noopener noreferrer"`; relative / non-http links stay in tab
+ *   - Unordered lists `- ` / `* `
+ *   - Ordered lists `1. `
+ *   - Blockquote `>`
+ *   - Horizontal rule `---`
+ *   - Fenced code blocks ` ``` ` — delegates to `CodeBlock` (language captured)
+ */
+import type { HTMLAttributes, Ref } from "react";
+export interface MarkdownViewProps extends HTMLAttributes<HTMLDivElement> {
+    /** Raw markdown string to render. */
+    content: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function MarkdownView({ content, className, ref, ...rest }: MarkdownViewProps): import("react").JSX.Element;

package/dist/components/content/MarkdownView/index.d.ts

@@ -0,0 +1,2 @@
+export type { MarkdownViewProps } from "./MarkdownView";
+export { MarkdownView } from "./MarkdownView";

package/dist/components/content/MarkdownView/markdown.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Zero-dependency markdown parser for MarkdownView.
+ *
+ * Supported subset:
+ *   - ATX headings: # through ######
+ *   - Paragraphs
+ *   - Bold: **text** or __text__
+ *   - Italic: *text* or _text_
+ *   - Inline code: `code`
+ *   - Links: [text](url)  — external http(s) links flagged isExternal=true
+ *   - Unordered lists: - item  or  * item
+ *   - Ordered lists: 1. item
+ *   - Blockquote: > text
+ *   - Horizontal rule: --- (or *** or ___) on its own line
+ *   - Fenced code blocks: ```lang … ```
+ *
+ * Security: returns a typed AST — no HTML string emitted, so raw angle-bracket
+ * content in source is passed as text nodes and escaped by React.
+ */
+export type InlineNode = {
+    type: "text";
+    value: string;
+} | {
+    type: "bold";
+    children: InlineNode[];
+} | {
+    type: "italic";
+    children: InlineNode[];
+} | {
+    type: "code";
+    value: string;
+} | {
+    type: "link";
+    href: string | null;
+    isExternal: boolean;
+    children: InlineNode[];
+};
+export type BlockNode = {
+    type: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+} | {
+    type: "paragraph";
+    children: InlineNode[];
+} | {
+    type: "blockquote";
+    children: InlineNode[];
+} | {
+    type: "hr";
+} | {
+    type: "fence";
+    lang: string;
+    code: string;
+} | {
+    type: "ul";
+    items: InlineNode[][];
+} | {
+    type: "ol";
+    items: InlineNode[][];
+};
+/**
+ * Sanitize a raw link href against dangerous URI schemes.
+ *
+ * Allow list:
+ *   - http: / https:  — absolute external URLs
+ *   - mailto: / tel:  — communication schemes
+ *   - No scheme at all (relative paths, anchors, query-only): allowed
+ *   - Protocol-relative (//) is allowed (no colon before the slashes)
+ *
+ * Reject list (anything with a scheme not in ALLOWED_HREF_SCHEMES):
+ *   - javascript:, vbscript:, data:, file:, and any other unknown scheme
+ *
+ * Obfuscation guards:
+ *   - Leading C0 controls (U+0000–U+001F), space (U+0020), and DEL (U+007F)
+ *     are stripped before analysis — these are the chars browsers ignore before
+ *     protocol determination per the WHATWG URL parser.
+ *   - ALL such chars are also removed from within the pre-colon scheme token
+ *     before comparison, neutralising "java\tscript:" style bypasses.
+ *
+ * Returns the original href string when safe, or null when rejected.
+ */
+export declare function sanitizeHref(raw: string): string | null;
+/**
+ * Parse inline markdown within a single line of text into InlineNode[].
+ * Processes in order: inline-code, bold, italic, links, plain text.
+ */
+export declare function parseInline(src: string): InlineNode[];
+/** Parse a full markdown string into a list of BlockNodes. */
+export declare function parseMarkdown(src: string): BlockNode[];

package/dist/components/content/MessageBubble/MessageBubble.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface MessageBubbleProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Product-owned visual content, such as attachment previews. */
+    children?: ReactNode;
+    /** Normalized plain-text message content. */
+    message?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/** Controlled user-message bubble shell for web transcript adapters. */
+export declare function MessageBubble({ children, className, message, ref, ...rest }: MessageBubbleProps): import("react").JSX.Element;

package/dist/components/content/MessageBubble/index.d.ts

@@ -0,0 +1 @@
+export * from "./MessageBubble";

package/dist/components/content/MetadataInspector/MetadataInspector.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface MetadataInspectorAction {
+    disabled?: boolean;
+    id: string;
+    label: ReactNode;
+    onSelect?: () => void;
+}
+export interface MetadataInspectorItem {
+    actions?: MetadataInspectorAction[];
+    href?: string;
+    id: string;
+    label: ReactNode;
+    value: ReactNode;
+}
+export interface MetadataInspectorSection {
+    description?: ReactNode;
+    id: string;
+    items: MetadataInspectorItem[];
+    title: ReactNode;
+}
+export interface MetadataInspectorProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    ref?: Ref<HTMLDivElement>;
+    /** Normalized groups of display-ready metadata. */
+    sections: MetadataInspectorSection[];
+}
+/**
+ * Controlled, schema-neutral metadata cards. Consumers normalize their data,
+ * navigation targets, and callbacks while this component owns presentation.
+ */
+export declare function MetadataInspector({ className, ref, sections, ...rest }: MetadataInspectorProps): import("react").JSX.Element;

package/dist/components/content/MetadataInspector/index.d.ts

@@ -0,0 +1 @@
+export { MetadataInspector, type MetadataInspectorAction, type MetadataInspectorItem, type MetadataInspectorProps, type MetadataInspectorSection, } from "./MetadataInspector";

package/dist/components/content/PlanCard/PlanCard.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface PlanCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    /** Product-rendered plan content, such as markdown or a native renderer. */
+    children: ReactNode;
+    /** Optional supporting copy supplied by the product adapter. */
+    description?: ReactNode;
+    /** Removes the card's block margin when it is nested in another surface. */
+    disableOuterSpacing?: boolean;
+    /** Optional product actions or status content. */
+    footer?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /** Optional title content supplied by the product adapter. */
+    title?: ReactNode;
+}
+export declare function PlanCard({ title, description, children, footer, disableOuterSpacing, className, ref, ...rest }: PlanCardProps): import("react").JSX.Element;

package/dist/components/content/PlanCard/index.d.ts

@@ -0,0 +1 @@
+export { PlanCard, type PlanCardProps } from "./PlanCard";