themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/features/comments/comments.types.d.ts

@@ -0,0 +1,369 @@
+/**
+ * Comments feature — type system.
+ *
+ * Generic in three axes:
+ *   - TUser     — author shape (id/name/avatar by default; consumer can extend)
+ *   - TMeta     — free-form per-comment payload (analytics, custom flags)
+ *   - TResource — string union of resource kinds the consumer wires up
+ *                 (e.g. `'user' | 'booking' | 'order'`)
+ *
+ * The feature is framework-agnostic: routing / i18n / data fetching arrive
+ * via callback props at the call site (`onSubmit`, `onDelete`, `onReact`, …).
+ * The library itself never imports any framework integration package
+ * (`@inertiajs/*`, `@tanstack/react-query`, `next/*`, `react-router*`,
+ * `vite-bundled-i18n/*`, `ziggy-js`). Library-wide display defaults
+ * (composer position, max attachments) come from `<UIProvider>` —
+ * see `@/lib/ui-provider`.
+ */
+import type { ComponentType, ReactNode } from 'react';
+import type { StringsProp } from '../../../lib/strings';
+import type { CommentsStrings } from './comments.strings';
+export interface CommentUser {
+    /** Stable identity for this entry. */
+    id?: string | number;
+    /** Display name. */
+    name?: string;
+    /** Leading avatar. */
+    avatar?: string;
+}
+export type CommentAttachmentStatus = 'uploading' | 'uploaded' | 'failed';
+export interface CommentAttachment {
+    /** Stable identity for this entry. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** Permalink. Optional while uploading. */
+    url?: string;
+    /** Size in bytes. */
+    size?: number;
+    /** Mime type — drives icon/preview pickers. */
+    mimeType?: string;
+    /** Optional thumbnail URL for image attachments. */
+    thumbnailUrl?: string;
+    /** Upload state — useful while a file is in flight. */
+    status?: CommentAttachmentStatus;
+    /** 0–100 progress for in-flight uploads. */
+    progress?: number;
+    /** Error message if `status === 'failed'`. */
+    error?: string;
+}
+import type { Mention, MentionResource, MentionsResourceSearch } from '../mentions/mentions.types';
+export interface CommentReaction {
+    /** Emoji or short token ("👍", "rocket"). */
+    emoji: string;
+    count: number;
+    /** True when the current user reacted with this emoji. */
+    mine?: boolean;
+    /** Optional list of user names for the tooltip. */
+    users?: string[];
+}
+export type CommentContentType = 'text' | 'html' | 'rich' | (string & {});
+export interface CommentData<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    id?: string;
+    /** HTML, rich-JSON, or plain text — controlled by `contentType`. */
+    content?: string;
+    contentType?: CommentContentType;
+    createdAt?: string;
+    updatedAt?: string;
+    user?: TUser;
+    /** Optional moderation/state hint shown next to the timestamp. */
+    status?: string;
+    isPinned?: boolean;
+    isEdited?: boolean;
+    /** Per-comment override — when false, the moderator menu is suppressed. */
+    canDelete?: boolean;
+    /** Per-comment override — when false, the edit affordance is suppressed. */
+    canEdit?: boolean;
+    /** Inline tags rendered as small pills. */
+    tagsArray?: string[] | Record<string, string>;
+    /** Attachments. */
+    attachments?: Array<CommentAttachment | null>;
+    /** Resource references rendered as badges and persisted alongside content. */
+    references?: ReadonlyArray<Mention<TResource>>;
+    /** Reactions on the comment. */
+    reactions?: ReadonlyArray<CommentReaction>;
+    /** Threading — id of the parent comment if this is a reply. */
+    replyToId?: string;
+    /** Free-form per-comment payload for consumer use. */
+    meta?: TMeta;
+}
+export interface CommentableContext {
+    /** Stable identity for this entry. */
+    id: string;
+    type: string;
+    moduleKey?: string;
+}
+export interface CommentFormValues<TResource extends string = string> {
+    /** HTML body produced by the rich text editor. */
+    content: string;
+    commentableId: string;
+    commentableType: string;
+    /** Optional module discriminator copied from `CommentableContext`. */
+    moduleKey?: string;
+    contentType?: CommentContentType;
+    /** Resource references collected via the picker. */
+    references?: ReadonlyArray<Mention<TResource>>;
+    /** Attachments — already uploaded by the consumer's `onUpload`. */
+    attachments?: ReadonlyArray<CommentAttachment>;
+    /** Optional id of the comment being replied-to. */
+    replyToId?: string;
+    /** Optional id of the comment being edited (when in edit mode). */
+    editingId?: string;
+}
+export interface CommentSubmitHelpers {
+    setErrors: (errors: Record<string, string>) => void;
+    reset: () => void;
+    setSubmitting: (submitting: boolean) => void;
+}
+export type CommentMutationKind = 'create' | 'update' | 'delete';
+export interface CommentDeleteMutationPayload {
+    commentId: string;
+}
+export type CommentMutationPayload<TResource extends string = string> = CommentFormValues<TResource> | CommentDeleteMutationPayload;
+/** Where the composer sits relative to the timeline. */
+export type CommentsComposerPosition = 'top' | 'bottom';
+export interface CommentsAccessors {
+    /** Resolve an attachment to a clickable URL. Defaults to `attachment.url`. */
+    getMediaUrl?: (media: CommentAttachment | null | undefined) => string | undefined;
+    /** Resolve an attachment to a display name. */
+    getMediaName?: (media: CommentAttachment | null | undefined) => string | undefined;
+    /** Resolve `comment.status` to a localised label. */
+    getStatusLabel?: (status: string) => string | undefined;
+    /** Format an ISO timestamp into a relative string. */
+    formatRelativeTime?: (iso: string) => string;
+}
+export interface CommentAttachmentUploadContext {
+    /** The original file the user picked / dropped. */
+    file: File;
+    /** Throttled progress callback the uploader can call. */
+    onProgress: (progress: number) => void;
+    /** AbortSignal — aborted when the user removes the chip mid-upload. */
+    signal: AbortSignal;
+}
+export interface CommentsAttachmentsConfig {
+    /**
+     * Async uploader. Resolves to a fully-formed `CommentAttachment` with
+     * a permanent `url`. Required to enable the attachment button.
+     */
+    onUpload?: (ctx: CommentAttachmentUploadContext) => Promise<CommentAttachment>;
+    /** Maximum file size in bytes. */
+    maxSize?: number;
+    /** Maximum simultaneous attachments per draft. */
+    maxFiles?: number;
+    /** Mime-type / extension filter passed to the file input. */
+    accept?: string;
+    /** Disable the attachment button entirely (default: false unless `onUpload` is missing). */
+    disabled?: boolean;
+}
+export interface CommentsConfig<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> extends CommentsAccessors {
+    /** Where the composer sits. Default: 'top'. */
+    composerPosition?: CommentsComposerPosition;
+    /** Strings deep-merged into descendant components. */
+    strings?: StringsProp<CommentsStrings>;
+    /** Resource catalogue used by the inline picker. */
+    resources?: Partial<Record<TResource, MentionResource<TResource>>>;
+    /**
+     * Global "rich suggestions" callback. Used when:
+     *   1. The user types one of the registered triggers (e.g. `@`, `#`)
+     *      followed by a needle — the picker opens automatically and calls
+     *      `onResourceSearch(needle, kind)` to populate results.
+     *   2. A `resources[kind]` entry is missing both `search` and
+     *      `suggestions` — the picker falls back to this callback.
+     *
+     * Per-kind `search` / `suggestions` always take precedence when present.
+     */
+    onResourceSearch?: MentionsResourceSearch<TResource>;
+    /** Attachment uploader config. */
+    attachments?: CommentsAttachmentsConfig;
+    /** Default permission flags. */
+    canComment?: boolean;
+    /** Whether the viewer may edit, delete, or pin others' comments. */
+    canModerate?: boolean;
+    /** Lifecycle callbacks — bubble through to descendants. */
+    onSubmit?: (values: CommentFormValues<TResource>, helpers: CommentSubmitHelpers) => void | Promise<void>;
+    onDelete?: (commentId: string) => void | Promise<void>;
+    onUpdate?: (commentId: string, values: CommentFormValues<TResource>, helpers: CommentSubmitHelpers) => void | Promise<void>;
+    /** Fires after a create/update/delete callback settles successfully. */
+    onAfterMutate?: (kind: CommentMutationKind, payload: CommentMutationPayload<TResource>) => void;
+    /** Receives rejected mutation callbacks without throwing through the DOM event. */
+    onError?: (error: unknown) => void;
+    onPinToggle?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    onReact?: (commentId: string, emoji: string) => void;
+    onReply?: (commentId: string) => void;
+    /** Optional sanitizer — runs on HTML before render. */
+    sanitizer?: (html: string) => string;
+}
+export interface CommentRenderItemContext<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    /** The comment to render. */
+    comment: CommentData<TUser, TMeta, TResource>;
+    /** Whether the viewer may edit, delete, or pin others' comments. */
+    canModerate: boolean;
+    onDelete?: (commentId: string) => void;
+    /** Removes an attachment from this comment; reveals the control when set. */
+    onAttachmentRemove?: (commentId: string, attachmentId: string) => void;
+    onEdit?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    /** Render the default item — useful when wrapping. */
+    defaultItem: ReactNode;
+}
+export interface CommentsSlots<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    /** Replaces the entire composer. */
+    composerSlot?: ReactNode;
+    /** Replaces the empty-state. */
+    emptySlot?: ReactNode;
+    /** Rendered above the composer + timeline. */
+    headerSlot?: ReactNode;
+    /** Rendered below the timeline. */
+    footerSlot?: ReactNode;
+    /** Per-comment custom rendering. */
+    renderItem?: (ctx: CommentRenderItemContext<TUser, TMeta, TResource>) => ReactNode;
+    /** Per-attachment custom rendering. */
+    renderAttachment?: (attachment: CommentAttachment) => ReactNode;
+    /** Per-reference custom rendering — overrides the resource type's `renderChip`. */
+    renderReference?: (reference: Mention<TResource>) => ReactNode;
+}
+export interface CommentsProps<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> extends CommentsAccessors, CommentsSlots<TUser, TMeta, TResource> {
+    /** Identifies the thread; passed to `onSubmit`. */
+    context: CommentableContext;
+    /** Comments to render, in display order. */
+    comments: ReadonlyArray<CommentData<TUser, TMeta, TResource>>;
+    /** Whether the viewer may post. */
+    canComment?: boolean;
+    /** Whether the viewer may edit, delete, or pin others' comments. */
+    canModerate?: boolean;
+    /** Composer position — overrides provider's `composerPosition`. */
+    composerPosition?: CommentsComposerPosition;
+    /** Maximum draft attachments for this Comments instance. */
+    maxAttachments?: number;
+    /** Whether attachment actions are available. Per-mount prop wins. */
+    allowAttachments?: boolean;
+    /** Whether reactions and their action are rendered. Per-mount prop wins. */
+    allowReactions?: boolean;
+    /** Whether reply actions are rendered. Per-mount prop wins. */
+    allowReplies?: boolean;
+    /** Hide the card chrome (title, padding) — render bare list+composer. */
+    bare?: boolean;
+    /** Override card title via strings; passing false hides it entirely. */
+    title?: ReactNode;
+    /** Lifecycle — overrides provider. */
+    onSubmit?: CommentsConfig<TUser, TMeta, TResource>['onSubmit'];
+    onDelete?: CommentsConfig<TUser, TMeta, TResource>['onDelete'];
+    /**
+     * Confirms before deleting. Default: `true`. Set `false` when the app already
+     * confirms upstream, so the user is not asked twice.
+     */
+    confirmDelete?: boolean;
+    /**
+     * Removes an attachment from a posted comment. Supplying it reveals the
+     * remove control on each attachment; without it they stay read-only, which
+     * is the previous behaviour.
+     */
+    onAttachmentRemove?: (commentId: string, attachmentId: string) => void | Promise<void>;
+    onUpdate?: CommentsConfig<TUser, TMeta, TResource>['onUpdate'];
+    onAfterMutate?: CommentsConfig<TUser, TMeta, TResource>['onAfterMutate'];
+    onError?: CommentsConfig<TUser, TMeta, TResource>['onError'];
+    onPinToggle?: CommentsConfig<TUser, TMeta, TResource>['onPinToggle'];
+    onReact?: CommentsConfig<TUser, TMeta, TResource>['onReact'];
+    onReply?: CommentsConfig<TUser, TMeta, TResource>['onReply'];
+    /** Resource registry override. */
+    resources?: CommentsConfig<TUser, TMeta, TResource>['resources'];
+    /** Global suggestion callback — overrides provider's `onResourceSearch`. */
+    onResourceSearch?: CommentsConfig<TUser, TMeta, TResource>['onResourceSearch'];
+    /** Attachment uploader override. */
+    attachments?: CommentsAttachmentsConfig;
+    /** Optional sanitizer applied to HTML comment bodies before rendering. */
+    sanitizer?: CommentsConfig<TUser, TMeta, TResource>['sanitizer'];
+    strings?: StringsProp<CommentsStrings>;
+    /** Optional className applied to the outer card. */
+    className?: string;
+    /** Optional avatar fallback component (renders initials by default). */
+    avatarComponent?: ComponentType<{
+        user: TUser | undefined;
+        size: 'sm' | 'md' | 'lg';
+    }>;
+}
+export interface CommentTimelineProps<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> extends CommentsAccessors, Pick<CommentsSlots<TUser, TMeta, TResource>, 'renderItem' | 'renderAttachment' | 'renderReference' | 'emptySlot'> {
+    /** Comments to render, in display order. */
+    comments: ReadonlyArray<CommentData<TUser, TMeta, TResource>>;
+    /** Whether the viewer may edit, delete, or pin others' comments. */
+    canModerate?: boolean;
+    onDelete?: (commentId: string) => void;
+    /** Removes an attachment from a posted comment; reveals the control when set. */
+    onAttachmentRemove?: (commentId: string, attachmentId: string) => void;
+    onEdit?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    onPinToggle?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    onReact?: (commentId: string, emoji: string) => void;
+    onReply?: (commentId: string) => void;
+    /** Shows the reaction controls. */
+    allowReactions?: boolean;
+    /** Shows the reply control and threads. */
+    allowReplies?: boolean;
+    /** Sanitises comment HTML before it renders. Defaults to the package allowlist. */
+    sanitizer?: CommentsConfig<TUser, TMeta, TResource>['sanitizer'];
+    strings?: StringsProp<CommentsStrings>;
+    /** Resource definitions used to resolve mentions. */
+    resources?: CommentsConfig<TUser, TMeta, TResource>['resources'];
+}
+export interface CommentItemProps<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> extends CommentsAccessors, Pick<CommentsSlots<TUser, TMeta, TResource>, 'renderAttachment' | 'renderReference'> {
+    /** The comment to render. */
+    comment: CommentData<TUser, TMeta, TResource>;
+    /** Whether the viewer may edit, delete, or pin others' comments. */
+    canModerate?: boolean;
+    onDelete?: (commentId: string) => void;
+    /** Removes an attachment from a posted comment; reveals the control when set. */
+    onAttachmentRemove?: (commentId: string, attachmentId: string) => void;
+    onEdit?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    onPinToggle?: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    onReact?: (commentId: string, emoji: string) => void;
+    onReply?: (commentId: string) => void;
+    /** Shows the reaction controls. */
+    allowReactions?: boolean;
+    /** Shows the reply control and threads. */
+    allowReplies?: boolean;
+    /** Sanitises comment HTML before it renders. Defaults to the package allowlist. */
+    sanitizer?: CommentsConfig<TUser, TMeta, TResource>['sanitizer'];
+    strings?: StringsProp<CommentsStrings>;
+    /** Resource definitions used to resolve mentions. */
+    resources?: CommentsConfig<TUser, TMeta, TResource>['resources'];
+}
+export interface CommentComposerProps<TResource extends string = string> {
+    /** What the comment is attached to — a new thread, a reply, or an edit. */
+    context: CommentableContext;
+    /** Whether the viewer may post. */
+    canComment?: boolean;
+    /** Shows the pending state and blocks repeat submissions. */
+    submitting?: boolean;
+    /** Validation messages for the composer. */
+    errors?: Record<string, string>;
+    /** Bumping this number resets the form. */
+    resetKey?: number;
+    /** Fired when an entry is submitted. */
+    onSubmit: (values: CommentFormValues<TResource>) => void | Promise<void>;
+    /** Fired when entry editing is cancelled. */
+    onCancel?: () => void;
+    /** When set, the composer is in edit mode for that comment. */
+    editingComment?: CommentData<CommentUser, unknown, TResource>;
+    /** When set, the composer identifies the comment receiving the reply. */
+    replyingTo?: {
+        commentId: string;
+        authorName?: string;
+    };
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<CommentsStrings>;
+    /** Resource definitions used to resolve mentions. */
+    resources?: CommentsConfig<CommentUser, unknown, TResource>['resources'];
+    onResourceSearch?: CommentsConfig<CommentUser, unknown, TResource>['onResourceSearch'];
+    /** Files staged on the draft. */
+    attachments?: CommentsAttachmentsConfig;
+    /** Maximum draft attachments for this composer instance. */
+    maxAttachments?: number;
+    /** Whether the attachment action is available. Per-mount prop wins. */
+    allowAttachments?: boolean;
+    /** Initial draft values. */
+    initialValues?: Partial<CommentFormValues<TResource>>;
+    /** Auto-focus the editor on mount. Default: false. */
+    autoFocus?: boolean;
+    /** Render the submit button on the toolbar (true, default) or as an explicit footer row (false). */
+    inlineSubmit?: boolean;
+    /** Placeholder override (also overridable via strings). */
+    placeholder?: string;
+}

package/dist/components/features/comments/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useAttachmentUpload } from './use-attachment-upload';
+export type { UseAttachmentUploadOptions, UseAttachmentUploadReturn, } from './use-attachment-upload';
+export { useComments } from './use-comments';
+export type { ComposerMode, UseCommentsOptions, UseCommentsReturn, } from './use-comments';

package/dist/components/features/comments/hooks/use-attachment-upload.d.ts

@@ -0,0 +1,28 @@
+import type { CommentAttachment, CommentsAttachmentsConfig } from '../comments.types';
+export interface UseAttachmentUploadOptions extends CommentsAttachmentsConfig {
+    /** Initial attachments — useful when editing an existing comment. */
+    initialAttachments?: ReadonlyArray<CommentAttachment>;
+    /** Fires when the list of uploaded attachments changes. */
+    onValueChange?: (attachments: ReadonlyArray<CommentAttachment>) => void;
+    /** Fires when a validation or upload error happens. */
+    onError?: (error: string) => void;
+}
+export interface UseAttachmentUploadReturn {
+    /** All attachments — uploading + uploaded + failed. */
+    attachments: ReadonlyArray<CommentAttachment>;
+    /** Subset of attachments that finished uploading. Use this in the form payload. */
+    uploadedAttachments: ReadonlyArray<CommentAttachment>;
+    /** True while at least one upload is in flight. */
+    isUploading: boolean;
+    /** Add files. Validates against `maxSize` / `maxFiles` first. */
+    addFiles: (files: ReadonlyArray<File> | FileList) => void;
+    /** Remove an attachment by id (aborts in-flight uploads). */
+    removeAttachment: (id: string) => void;
+    /** Retry a failed upload. */
+    retryAttachment: (id: string) => void;
+    /** Replace the list (used when editing or after submit). */
+    setAttachments: (attachments: ReadonlyArray<CommentAttachment>) => void;
+    /** Clear the list and abort everything in flight. */
+    reset: () => void;
+}
+export declare function useAttachmentUpload(options?: UseAttachmentUploadOptions): UseAttachmentUploadReturn;

package/dist/components/features/comments/hooks/use-comments.d.ts

@@ -0,0 +1,34 @@
+import type { CommentData, CommentFormValues, CommentSubmitHelpers, CommentUser, CommentsConfig } from '../comments.types';
+export type ComposerMode<TResource extends string = string, TUser extends CommentUser = CommentUser, TMeta = unknown> = {
+    kind: 'idle';
+} | {
+    kind: 'editing';
+    comment: CommentData<TUser, TMeta, TResource>;
+} | {
+    kind: 'replying';
+    commentId: string;
+    authorName?: string;
+};
+export interface UseCommentsOptions<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    onSubmit?: CommentsConfig<TUser, TMeta, TResource>['onSubmit'];
+    onUpdate?: CommentsConfig<TUser, TMeta, TResource>['onUpdate'];
+    onDelete?: CommentsConfig<TUser, TMeta, TResource>['onDelete'];
+    onAfterMutate?: CommentsConfig<TUser, TMeta, TResource>['onAfterMutate'];
+    onError?: CommentsConfig<TUser, TMeta, TResource>['onError'];
+}
+export interface UseCommentsReturn<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    composerMode: ComposerMode<TResource, TUser, TMeta>;
+    isSubmitting: boolean;
+    formErrors: Record<string, string>;
+    resetKey: number;
+    startReply: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    startEdit: (comment: CommentData<TUser, TMeta, TResource>) => void;
+    cancelComposerMode: () => void;
+    submit: (values: CommentFormValues<TResource>) => Promise<void>;
+    deleteComment: (id: string) => Promise<void>;
+    /** Imperative reset — bumps `resetKey` so the composer clears itself. */
+    resetComposer: () => void;
+    /** Helpers exposed to onSubmit/onUpdate. */
+    helpers: CommentSubmitHelpers;
+}
+export declare function useComments<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string>(options?: UseCommentsOptions<TUser, TMeta, TResource>): UseCommentsReturn<TUser, TMeta, TResource>;

package/dist/components/features/comments/index.d.ts

@@ -0,0 +1,8 @@
+export { Comments } from './comments';
+export { useResolvedAccessors, useResolvedStrings, } from './comments-provider';
+export { CommentItem, CommentTimeline, CommentComposer, CommentContent, CommentAttachmentChip, CommentEmpty, makeReplyEyebrow, } from './partials';
+export type { CommentAttachmentChipProps, CommentEmptyProps, CommentComposerHandle, CommentContentProps, } from './partials';
+export { useAttachmentUpload, useComments, } from './hooks';
+export type { UseAttachmentUploadOptions, UseAttachmentUploadReturn, UseCommentsOptions, UseCommentsReturn, ComposerMode, } from './hooks';
+export { defaultCommentsStrings, type CommentsStrings, } from './comments.strings';
+export type { CommentableContext, CommentAttachment, CommentAttachmentStatus, CommentAttachmentUploadContext, CommentComposerProps, CommentContentType, CommentData, CommentFormValues, CommentItemProps, CommentDeleteMutationPayload, CommentMutationKind, CommentMutationPayload, CommentReaction, CommentRenderItemContext, CommentSubmitHelpers, CommentTimelineProps, CommentUser, CommentsAccessors, CommentsAttachmentsConfig, CommentsComposerPosition, CommentsConfig, CommentsProps, CommentsSlots, } from './comments.types';

package/dist/components/features/comments/partials/comment-attachment-chip.d.ts

@@ -0,0 +1,23 @@
+import type { FC } from 'react';
+import { type StringsProp } from '../../../../lib/strings';
+import type { CommentAttachment, CommentsAccessors } from '../comments.types';
+import { type CommentsStrings } from '../comments.strings';
+export interface CommentAttachmentChipProps {
+    /** The attachment this chip represents. */
+    attachment: CommentAttachment;
+    /** Editable mode shows a remove button. */
+    editable?: boolean;
+    /** Fired when an entry is removed. */
+    onRemove?: (id: string) => void;
+    /** Fired when the user retries after an entry failure. */
+    onRetry?: (id: string) => void;
+    /** Reads the fields this surface needs off your own shape. */
+    accessors?: CommentsAccessors;
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<CommentsStrings>;
+    /** Compact chips have smaller text and tighter padding. */
+    compact?: boolean;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+export declare const CommentAttachmentChip: FC<CommentAttachmentChipProps>;

package/dist/components/features/comments/partials/comment-composer.d.ts

@@ -0,0 +1,12 @@
+import type { ReactElement, RefAttributes } from 'react';
+import type { CommentComposerProps } from '../comments.types';
+export interface CommentComposerHandle {
+    focus(): void;
+    clear(): void;
+    /** Imperatively set the draft body. */
+    setBody(html: string): void;
+}
+/** Preserve the consumer's resource-kind union through the forwarded-ref boundary. */
+export declare const CommentComposer: <TResource extends string = string>(props: CommentComposerProps<TResource> & RefAttributes<CommentComposerHandle>) => ReactElement | null;
+/** Helper export for templated reply eyebrow. */
+export declare function makeReplyEyebrow(template: string, name?: string): string;

package/dist/components/features/comments/partials/comment-content.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { CommentData, CommentUser, CommentsConfig, CommentsSlots } from '../comments.types';
+export interface CommentContentProps<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string> {
+    /** The comment to render. */
+    comment: CommentData<TUser, TMeta, TResource>;
+    /** Resource registry — passed through to `<MentionContent>`. */
+    resources?: CommentsConfig<TUser, TMeta, TResource>['resources'];
+    /** Replaces the default rendering of an inline reference. */
+    renderReference?: CommentsSlots<TUser, TMeta, TResource>['renderReference'];
+    /** Optional sanitizer override. The package safe allowlist is the default. */
+    sanitizer?: (html: string) => string;
+}
+export declare function CommentContent<TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string>(props: CommentContentProps<TUser, TMeta, TResource>): ReactNode;

package/dist/components/features/comments/partials/comment-empty.d.ts

@@ -0,0 +1,12 @@
+import type { FC, ReactNode } from 'react';
+import type { StringsProp } from '../../../../lib/strings';
+import type { CommentsStrings } from '../comments.strings';
+export interface CommentEmptyProps {
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<CommentsStrings>;
+    /** Leading glyph. */
+    icon?: ReactNode;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+export declare const CommentEmpty: FC<CommentEmptyProps>;

package/dist/components/features/comments/partials/comment-item.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import type { CommentItemProps, CommentUser } from '../comments.types';
+export declare const CommentItem: <TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string>(props: CommentItemProps<TUser, TMeta, TResource>) => ReturnType<FC>;

package/dist/components/features/comments/partials/comment-timeline.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import type { CommentTimelineProps, CommentUser } from '../comments.types';
+export declare const CommentTimeline: <TUser extends CommentUser = CommentUser, TMeta = unknown, TResource extends string = string>(props: CommentTimelineProps<TUser, TMeta, TResource>) => ReturnType<FC>;

package/dist/components/features/comments/partials/index.d.ts

@@ -0,0 +1,9 @@
+export { CommentItem } from './comment-item';
+export { CommentTimeline } from './comment-timeline';
+export { CommentComposer, type CommentComposerHandle, makeReplyEyebrow, } from './comment-composer';
+export { CommentContent } from './comment-content';
+export type { CommentContentProps } from './comment-content';
+export { CommentAttachmentChip } from './comment-attachment-chip';
+export type { CommentAttachmentChipProps } from './comment-attachment-chip';
+export { CommentEmpty } from './comment-empty';
+export type { CommentEmptyProps } from './comment-empty';

package/dist/components/features/data-view/data-view-filtering.d.ts

@@ -0,0 +1,3 @@
+import { type ActiveFilter, type FilterConfig } from '../filters';
+import type { DataViewFilterValueGetter } from './data-view.types';
+export declare function applyDataViewFilters<TData extends object>(data: readonly TData[], activeFilters: readonly ActiveFilter[], filters: readonly FilterConfig[], getFilterValue?: DataViewFilterValueGetter<TData>): readonly TData[];

package/dist/components/features/data-view/data-view.d.ts

@@ -0,0 +1,7 @@
+import type { DataViewPaginationProps, DataViewProps, DataViewShellProps, DataViewTableFrameProps, DataViewToolbarProps, SavedViewTabsProps } from './data-view.types';
+export declare function DataViewShell({ children, header, toolbar, footer, emptySlot, empty: emptyState, className, contentClassName, }: DataViewShellProps): import("react").JSX.Element;
+export declare function DataViewToolbar({ leading, search, filters, views, actions, className }: DataViewToolbarProps): import("react").JSX.Element;
+export declare function DataViewTableFrame({ toolbar, children, footer, className, toolbarClassName, contentClassName, footerClassName, }: DataViewTableFrameProps): import("react").JSX.Element;
+export declare function DataView<TData extends object, TValue = unknown>({ data, columns, filtering, table, slots, className, }: DataViewProps<TData, TValue>): import("react").JSX.Element;
+export declare function DataViewPagination({ page, pageCount, total, onPageChange, disabled, className, strings: stringsProp, }: DataViewPaginationProps): import("react").JSX.Element;
+export declare function SavedViewTabs({ views, value, onValueChange, className }: SavedViewTabsProps): import("react").JSX.Element;

package/dist/components/features/data-view/data-view.strings.d.ts

@@ -0,0 +1,9 @@
+export interface DataViewPaginationStrings {
+    /** Current page, 1-based. */
+    page: string;
+    previous: string;
+    next: string;
+}
+export declare const defaultDataViewPaginationStrings: DataViewPaginationStrings;
+/** Default for the directly overrideable `filterTabsLabel` control label. */
+export declare const defaultDataViewFilterTabsLabel = "View";