@ciridae/ui 0.7.1 → 0.8.1

package/dist/components/blocks/feedback-composer.js

@@ -1,112 +1,82 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as React from "react";
 import { FeedbackComposerActions, FeedbackSubmittedState, FeedbackTypeField, } from "./feedback-composer-parts";
+import { FeedbackEmergencyFields } from "./feedback-emergency-fields";
+import { submitFeedbackComposer } from "./submit-feedback-composer";
+import { useFeedbackComposerState } from "./use-feedback-composer-state";
 import { FileUploadField } from "../ui/file-upload-field";
 import { Field, FieldContent, FieldError, FieldGroup, FieldLabel } from "../ui/field";
 import { Input } from "../ui/input";
 import { Textarea } from "../ui/textarea";
 function FeedbackComposer(props) {
-    const state = useFeedbackComposerState(props.defaultType ?? "bug");
+    // Without its controls, emergency could never be confirmed — a hidden
+    // emergency default would soft-lock submit — so it needs urgencyEnabled.
+    const defaultUrgency = props.urgencyEnabled ? (props.defaultUrgency ?? "normal") : "normal";
+    const state = useFeedbackComposerState(props.defaultType ?? "bug", defaultUrgency);
     const ids = useFeedbackComposerIds();
-    if (state.submitResult) {
+    const { onDirtyChange, onUrgencyChange } = props;
+    React.useEffect(() => {
+        onDirtyChange?.(state.isDirty);
+    }, [onDirtyChange, state.isDirty]);
+    React.useEffect(() => {
+        onUrgencyChange?.(state.urgency);
+    }, [onUrgencyChange, state.urgency]);
+    if (state.isSubmitted) {
         return (_jsx(FeedbackSubmittedState, { onCancel: props.onCancel, onSendAnother: () => {
                 state.resetForm();
                 props.onSubmittedChange?.(false);
-            }, referenceId: state.submitResult.referenceId }));
+            } }));
     }
     return _jsx(FeedbackComposerForm, { ids: ids, props: props, state: state });
 }
 function FeedbackComposerForm({ ids, props, state, }) {
     const isSubmitting = props.isSubmitting ?? false;
-    return (_jsxs("form", { className: "grid gap-(--panel-gap)", id: props.formId, onSubmit: (event) => submitFeedback(event, props, state), children: [_jsxs(FieldGroup, { children: [_jsx(FeedbackTypeField, { disabled: isSubmitting, onTypeChange: state.setType, type: state.type }), _jsx(FeedbackSubjectField, { disabled: isSubmitting, error: state.error, fieldId: ids.subjectId, onSubjectChange: state.setSubject, subject: state.subject }), _jsx(FeedbackDescriptionField, { description: state.description, disabled: isSubmitting, error: state.error, fieldId: ids.descriptionId, onDescriptionChange: state.setDescription }), _jsx(FeedbackAttachmentsField, { props: props, state: state }), state.submitError ? _jsx(FieldError, { children: state.submitError }) : null] }), props.actions === "external" ? null : (_jsx(FeedbackComposerActions, { isSubmitting: isSubmitting, onCancel: props.onCancel }))] }));
+    return (_jsxs("form", { className: "grid gap-(--panel-gap)", id: props.formId, onSubmit: (event) => submitFeedbackComposer(event, props, state), children: [_jsxs(FieldGroup, { children: [state.urgency === "normal" ? (_jsx(FeedbackTypeField, { disabled: isSubmitting, onTypeChange: state.setType, type: state.type })) : null, _jsx(FeedbackSubjectField, { disabled: isSubmitting, error: state.error, errorId: ids.subjectErrorId, fieldId: ids.subjectId, onSubjectChange: state.setSubject, subject: state.subject }), _jsx(FeedbackDescriptionField, { description: state.description, disabled: isSubmitting, error: state.error, errorId: ids.descriptionErrorId, fieldId: ids.descriptionId, onDescriptionChange: state.setDescription }), _jsx(FeedbackAttachmentsField, { props: props, state: state }), _jsx(FeedbackComposerEmergencySection, { ids: ids, props: props, state: state }), state.submitError ? _jsx(FieldError, { children: state.submitError }) : null] }), props.actions === "external" ? null : (_jsx(FeedbackComposerActions, { isSubmitting: isSubmitting, onCancel: props.onCancel, urgency: state.urgency }))] }));
 }
-function FeedbackSubjectField({ disabled, error, fieldId, onSubjectChange, subject, }) {
-    return (_jsxs(Field, { "data-invalid": error === "subject", children: [_jsx(FieldContent, { children: _jsx(FieldLabel, { htmlFor: fieldId, required: true, children: "Subject" }) }), _jsx(Input, { "aria-invalid": error === "subject", "aria-required": "true", disabled: disabled, id: fieldId, onChange: (event) => onSubjectChange(event.target.value), placeholder: "Short subject for the team", value: subject }), error === "subject" ? _jsx(FieldError, { children: "Subject is required." }) : null] }));
+function FeedbackSubjectField({ disabled, error, errorId, fieldId, onSubjectChange, subject, }) {
+    const invalid = error === "subject";
+    return (_jsxs(Field, { "data-invalid": invalid, children: [_jsx(FieldContent, { children: _jsx(FieldLabel, { htmlFor: fieldId, required: true, children: "Subject" }) }), _jsx(Input, { "aria-describedby": invalid ? errorId : undefined, "aria-invalid": invalid, "aria-required": "true", disabled: disabled, id: fieldId, maxLength: 255, onChange: (event) => onSubjectChange(event.target.value), placeholder: "Short subject for the team", value: subject }), invalid ? _jsx(FieldError, { id: errorId, children: "Subject is required." }) : null] }));
 }
-function FeedbackDescriptionField({ description, disabled, error, fieldId, onDescriptionChange, }) {
-    return (_jsxs(Field, { "data-invalid": error === "description", children: [_jsx(FieldContent, { children: _jsx(FieldLabel, { htmlFor: fieldId, required: true, children: "Feedback" }) }), _jsx(Textarea, { "aria-invalid": error === "description", "aria-required": "true", className: "min-h-40", disabled: disabled, id: fieldId, onChange: (event) => onDescriptionChange(event.target.value), placeholder: "What happened, what did you expect, or what would you like to see?", rows: 6, value: description }), error === "description" ? _jsx(FieldError, { children: "Feedback is required." }) : null] }));
+function FeedbackDescriptionField({ description, disabled, error, errorId, fieldId, onDescriptionChange, }) {
+    const invalid = error === "description";
+    return (_jsxs(Field, { "data-invalid": invalid, children: [_jsx(FieldContent, { children: _jsx(FieldLabel, { htmlFor: fieldId, required: true, children: "Feedback" }) }), _jsx(Textarea, { "aria-describedby": invalid ? errorId : undefined, "aria-invalid": invalid, "aria-required": "true", className: "min-h-40", disabled: disabled, id: fieldId, maxLength: 10000, onChange: (event) => onDescriptionChange(event.target.value), placeholder: "What happened, what did you expect, or what would you like to see?", rows: 6, value: description }), invalid ? _jsx(FieldError, { id: errorId, children: "Feedback is required." }) : null] }));
 }
 function FeedbackAttachmentsField({ props, state, }) {
     if (props.attachmentsEnabled === false)
         return null;
     return (_jsx(FileUploadField, { acceptedFileTypes: props.acceptedFileTypes ?? "image/*,.pdf,.csv,.txt,.doc,.docx,.xls,.xlsx", disabled: props.isSubmitting ?? false, files: state.attachments, maxAttachmentSizeMb: props.maxAttachmentSizeMb, maxAttachments: props.maxAttachments, onFilesChange: state.setAttachments, showConstraints: false, variant: "dropzone" }));
 }
+function FeedbackComposerEmergencySection({ ids, props, state, }) {
+    if (!props.urgencyEnabled)
+        return null;
+    return (_jsx(FeedbackEmergencyFields, { affectedScope: state.affectedScope, affectedScopeId: ids.emergencyAffectedScopeId, confirmed: state.emergencyConfirmed, confirmationDescriptionId: ids.emergencyConfirmationDescriptionId, confirmationErrorId: ids.emergencyConfirmationErrorId, confirmationId: ids.emergencyConfirmationId, confirmationInvalid: state.error === "emergency_confirmation", disabled: props.isSubmitting ?? false, isEmergency: state.urgency === "emergency", onAffectedScopeChange: state.setAffectedScope, onConfirmedChange: (confirmed) => {
+            state.setEmergencyConfirmed(confirmed);
+            if (confirmed && state.error === "emergency_confirmation") {
+                state.setError(undefined);
+            }
+        }, onEmergencyChange: (emergency) => {
+            state.setUrgency(emergency ? "emergency" : "normal");
+            if (emergency) {
+                state.setType("bug");
+            }
+            else {
+                // leaving emergency mode abandons its scope and confirmation
+                state.setAffectedScope("unknown");
+                state.setEmergencyConfirmed(false);
+            }
+        } }));
+}
 function useFeedbackComposerIds() {
     const formId = React.useId();
     return {
+        descriptionErrorId: `${formId}-description-error`,
         descriptionId: `${formId}-description`,
+        emergencyAffectedScopeId: `${formId}-emergency-affected-scope`,
+        emergencyConfirmationDescriptionId: `${formId}-emergency-confirmation-description`,
+        emergencyConfirmationErrorId: `${formId}-emergency-confirmation-error`,
+        emergencyConfirmationId: `${formId}-emergency-confirmation`,
+        subjectErrorId: `${formId}-subject-error`,
         subjectId: `${formId}-subject`,
     };
 }
-function useFeedbackComposerState(defaultType) {
-    const [attachments, setAttachments] = React.useState([]);
-    const [description, setDescription] = React.useState("");
-    const [error, setError] = React.useState();
-    const [submitError, setSubmitError] = React.useState();
-    const [submitResult, setSubmitResult] = React.useState();
-    const [subject, setSubject] = React.useState("");
-    const [type, setType] = React.useState(defaultType);
-    React.useEffect(() => {
-        setType(defaultType);
-    }, [defaultType]);
-    const resetForm = () => {
-        setAttachments([]);
-        setDescription("");
-        setError(undefined);
-        setSubmitError(undefined);
-        setSubmitResult(undefined);
-        setSubject("");
-        setType(defaultType);
-    };
-    return {
-        attachments,
-        description,
-        error,
-        resetForm,
-        setAttachments,
-        setDescription,
-        setError,
-        setSubmitError,
-        setSubmitResult,
-        setSubject,
-        setType,
-        submitError,
-        submitResult,
-        subject,
-        type,
-    };
-}
-async function submitFeedback(event, props, state) {
-    event.preventDefault();
-    const trimmedDescription = state.description.trim();
-    const trimmedSubject = state.subject.trim();
-    const validationError = getValidationError({
-        description: trimmedDescription,
-        subject: trimmedSubject,
-    });
-    state.setError(validationError);
-    state.setSubmitError(undefined);
-    if (validationError)
-        return;
-    try {
-        const result = await props.onSubmit({
-            attachments: state.attachments,
-            description: trimmedDescription,
-            subject: trimmedSubject,
-            type: state.type,
-        });
-        state.setSubmitResult(result ?? {});
-        props.onSubmittedChange?.(true);
-    }
-    catch {
-        state.setSubmitError("Unable to submit feedback. Please try again.");
-    }
-}
-function getValidationError({ description, subject, }) {
-    if (!subject)
-        return "subject";
-    if (!description)
-        return "description";
-    return undefined;
-}
 export { FeedbackComposer, };

package/dist/components/blocks/feedback-detail-sheet.d.ts

@@ -1,9 +1,15 @@
-import type * as React from "react";
-import { type StakeholderFeedbackItem } from "./feedback-tracking-types";
+import * as React from "react";
+import { type FeedbackStatus, type StakeholderFeedbackItem } from "./feedback-tracking-types";
 type FeedbackDetailSheetProps = {
+    /** Rendered after the submission — the slot for a comment thread. */
+    conversation?: React.ReactNode;
     feedback?: StakeholderFeedbackItem;
     onOpenChange: (open: boolean) => void;
+    /** Renders a status select when present; the app owns the save. */
+    onStatusChange?: (status: FeedbackStatus) => void;
     open: boolean;
+    /** The selection being saved: shown and locked in the select while set. */
+    pendingStatus?: FeedbackStatus;
 };
-declare function FeedbackDetailSheet({ feedback, onOpenChange, open }: FeedbackDetailSheetProps): React.JSX.Element;
+declare function FeedbackDetailSheet({ conversation, feedback, onOpenChange, onStatusChange, open, pendingStatus, }: FeedbackDetailSheetProps): React.JSX.Element;
 export { FeedbackDetailSheet, type FeedbackDetailSheetProps };

package/dist/components/blocks/feedback-detail-sheet.js

@@ -1,27 +1,45 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from "react";
 import { PaperclipIcon } from "lucide-react";
 import { formatFeedbackTimestampFull, getFeedbackTimestampDateTime } from "./feedback-date-format";
 import { FeedbackStatusBadge } from "./feedback-status-badge";
 import { FeedbackTypeBadge } from "./feedback-type-badge";
-import { getFeedbackInitials } from "./feedback-tracking-types";
+import { feedbackStatusLabels, feedbackStatusValues, getFeedbackInitials, } from "./feedback-tracking-types";
 import { Avatar, AvatarFallback, AvatarImage } from "../ui/avatar";
 import { Button } from "../ui/button";
 import { Card } from "../ui/card";
-import { Item, ItemContent, ItemGroup, ItemGroupItem, ItemMedia, ItemTitle } from "../ui/item";
+import { Item, ItemActions, ItemContent, ItemDescription, ItemGroup, ItemGroupItem, ItemMedia, ItemTitle, } from "../ui/item";
+import { NativeSelect, NativeSelectOption } from "../ui/native-select";
 import { PropertyList, PropertyListItem, PropertyListLabel, PropertyListValue, } from "../ui/property-list";
 import { Sheet, SheetBody, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, } from "../ui/sheet";
-function FeedbackDetailSheet({ feedback, onOpenChange, open }) {
-    return (_jsx(Sheet, { onOpenChange: onOpenChange, open: open, children: _jsxs(SheetContent, { size: "md", children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: feedback?.subject ?? "Feedback" }), _jsx(SheetDescription, { children: "Review the original submission and current progress." })] }), _jsx(SheetBody, { className: "grid content-start gap-(--panel-gap) pb-(--panel-padding)", children: feedback ? _jsx(FeedbackDetailContent, { feedback: feedback }) : null }), _jsx(SheetFooter, { children: _jsx(Button, { onClick: () => onOpenChange(false), type: "button", children: "Done" }) })] }) }));
-}
-function FeedbackDetailContent({ feedback }) {
-    return (_jsxs(_Fragment, { children: [_jsx(FeedbackDetailSummary, { feedback: feedback }), _jsx(FeedbackDetailBody, { feedback: feedback }), _jsx(FeedbackDetailAttachments, { feedback: feedback })] }));
+function FeedbackDetailSheet({ conversation, feedback, onOpenChange, onStatusChange, open, pendingStatus, }) {
+    return (_jsx(Sheet, { onOpenChange: onOpenChange, open: open, children: _jsxs(SheetContent, { size: "md", children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: feedback?.subject ?? "Feedback" }), _jsx(SheetDescription, { children: onStatusChange
+                                ? "Review the submission and set where it stands."
+                                : "Review the original submission and current progress." })] }), _jsxs(SheetBody, { className: "grid content-start gap-(--panel-gap) pb-(--panel-padding)", children: [feedback ? (_jsx(FeedbackDetailContent, { feedback: feedback, onStatusChange: onStatusChange, pendingStatus: pendingStatus })) : null, feedback ? conversation : null] }), _jsx(SheetFooter, { children: _jsx(Button, { onClick: () => onOpenChange(false), type: "button", children: "Done" }) })] }) }));
+}
+function FeedbackDetailContent({ feedback, onStatusChange, pendingStatus, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(FeedbackDetailSummary, { feedback: feedback }), onStatusChange ? (_jsx(FeedbackDetailStatusSection, { onStatusChange: onStatusChange, pendingStatus: pendingStatus, status: feedback.status })) : null, _jsx(FeedbackDetailBody, { feedback: feedback }), _jsx(FeedbackDetailAttachments, { feedback: feedback })] }));
+}
+/**
+ * Presentation only — the app owns the save. Selecting fires onStatusChange;
+ * while pendingStatus is set the select shows it and locks, so the sheet
+ * reflects the in-flight decision until the app's write settles.
+ */
+function FeedbackDetailStatusSection({ onStatusChange, pendingStatus, status, }) {
+    const selectId = React.useId();
+    return (_jsxs("div", { className: "grid gap-2", children: [_jsx("label", { className: "text-meta text-muted-foreground", htmlFor: selectId, children: "Status" }), _jsx(NativeSelect, { disabled: pendingStatus !== undefined, id: selectId, onChange: (event) => {
+                    const next = feedbackStatusValues.find((value) => value === event.target.value);
+                    if (next && next !== status)
+                        onStatusChange(next);
+                }, value: pendingStatus ?? status, children: feedbackStatusValues.map((value) => (_jsx(NativeSelectOption, { value: value, children: feedbackStatusLabels[value] }, value))) })] }));
 }
 function FeedbackDetailSummary({ feedback }) {
     const submitter = feedback.submittedBy;
-    return (_jsxs("div", { className: "flex min-w-0 items-start justify-between gap-3 rounded-lg border bg-card p-(--panel-padding)", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-3", children: [_jsxs(Avatar, { children: [_jsx(AvatarImage, { alt: "", src: submitter.imageUrl }), _jsx(AvatarFallback, { children: getFeedbackInitials(submitter.name, submitter.email) })] }), _jsxs("div", { className: "min-w-0", children: [_jsx("div", { className: "truncate text-sm font-medium text-foreground", children: submitter.name }), _jsx("div", { className: "truncate text-xs text-muted-foreground", children: submitter.organization ?? submitter.email ?? "Stakeholder" })] })] }), _jsx(FeedbackStatusBadge, { status: feedback.status })] }));
+    const affiliation = submitter.organization ?? submitter.email ?? "Stakeholder";
+    return (_jsxs(Item, { variant: "outline", children: [_jsx(ItemMedia, { children: _jsxs(Avatar, { children: [_jsx(AvatarImage, { alt: "", src: submitter.imageUrl }), _jsx(AvatarFallback, { children: getFeedbackInitials(submitter.name, submitter.email) })] }) }), _jsxs(ItemContent, { children: [_jsx(ItemTitle, { className: "max-w-full truncate", title: submitter.name, children: submitter.name }), _jsx(ItemDescription, { title: affiliation, children: affiliation })] }), _jsx(ItemActions, { children: _jsx(FeedbackStatusBadge, { status: feedback.status }) })] }));
 }
 function FeedbackDetailBody({ feedback }) {
-    return (_jsxs("div", { className: "grid gap-(--panel-gap)", children: [_jsxs(PropertyList, { children: [_jsx(FeedbackProperty, { label: "Type", children: _jsx(FeedbackTypeBadge, { type: feedback.type }) }), _jsx(FeedbackProperty, { label: "Submitted", children: _jsx(FeedbackDetailDateValue, { value: feedback.submittedAt }) }), _jsx(FeedbackProperty, { label: "Updated", children: _jsx(FeedbackDetailDateValue, { value: feedback.updatedAt }) }), feedback.referenceId ? (_jsx(FeedbackProperty, { label: "Reference", children: _jsx("span", { className: "font-mono text-xs tabular-nums", children: feedback.referenceId }) })) : null] }), _jsxs(Card, { className: "grid gap-2 p-(--panel-padding)", children: [_jsx("div", { className: "text-meta text-muted-foreground", children: "Feedback" }), _jsx("p", { className: "text-sm whitespace-pre-wrap text-foreground", children: feedback.description })] })] }));
+    return (_jsxs("div", { className: "grid gap-(--panel-gap)", children: [_jsxs(PropertyList, { children: [_jsx(FeedbackProperty, { label: "Type", children: _jsx(FeedbackTypeBadge, { type: feedback.type }) }), _jsx(FeedbackProperty, { label: "Submitted", children: _jsx(FeedbackDetailDateValue, { value: feedback.submittedAt }) }), _jsx(FeedbackProperty, { label: "Updated", children: _jsx(FeedbackDetailDateValue, { value: feedback.updatedAt }) }), feedback.referenceId ? (_jsx(FeedbackProperty, { label: "Reference", children: _jsx("span", { className: "font-mono text-xs tabular-nums", children: feedback.referenceId }) })) : null] }), _jsxs(Card, { className: "grid gap-2 p-(--panel-padding)", children: [_jsx("div", { className: "text-meta text-muted-foreground", children: "Feedback" }), feedback.description ? (_jsx("p", { className: "text-sm whitespace-pre-wrap text-foreground", children: feedback.description })) : (_jsx("p", { className: "text-sm text-muted-foreground", children: "No description provided." }))] })] }));
 }
 function FeedbackProperty({ children, label }) {
     return (_jsxs(PropertyListItem, { children: [_jsx(PropertyListLabel, { children: label }), _jsx(PropertyListValue, { children: children })] }));

package/dist/components/blocks/feedback-emergency-fields.d.ts

@@ -0,0 +1,17 @@
+import type { FeedbackAffectedScope } from "./feedback-composer-types";
+type FeedbackEmergencyFieldsProps = {
+    affectedScope: FeedbackAffectedScope;
+    affectedScopeId: string;
+    confirmed: boolean;
+    confirmationDescriptionId: string;
+    confirmationErrorId: string;
+    confirmationId: string;
+    confirmationInvalid: boolean;
+    disabled: boolean;
+    onAffectedScopeChange: (scope: FeedbackAffectedScope) => void;
+    onConfirmedChange: (confirmed: boolean) => void;
+    onEmergencyChange: (emergency: boolean) => void;
+    isEmergency: boolean;
+};
+declare function FeedbackEmergencyFields({ affectedScope, affectedScopeId, confirmed, confirmationDescriptionId, confirmationErrorId, confirmationId, confirmationInvalid, disabled, onAffectedScopeChange, onConfirmedChange, onEmergencyChange, isEmergency, }: FeedbackEmergencyFieldsProps): import("@types/react").JSX.Element;
+export { FeedbackEmergencyFields, type FeedbackEmergencyFieldsProps };

package/dist/components/blocks/feedback-emergency-fields.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AlertTriangleIcon } from "lucide-react";
+import { Alert, AlertDescription, AlertTitle } from "../ui/alert";
+import { Button } from "../ui/button";
+import { Checkbox } from "../ui/checkbox";
+import { Field, FieldContent, FieldDescription, FieldError, FieldLabel } from "../ui/field";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../ui/select";
+function FeedbackEmergencyFields({ affectedScope, affectedScopeId, confirmed, confirmationDescriptionId, confirmationErrorId, confirmationId, confirmationInvalid, disabled, onAffectedScopeChange, onConfirmedChange, onEmergencyChange, isEmergency, }) {
+    if (!isEmergency)
+        return _jsx(FeedbackEmergencyEntry, { disabled: disabled, onEmergencyChange: onEmergencyChange });
+    return (_jsxs("div", { className: "grid gap-(--panel-gap)", children: [_jsx(FeedbackEmergencyNotice, {}), _jsx(FeedbackAffectedScopeField, { affectedScope: affectedScope, affectedScopeId: affectedScopeId, disabled: disabled, onAffectedScopeChange: onAffectedScopeChange }), _jsx(FeedbackEmergencyConfirmation, { confirmed: confirmed, descriptionId: confirmationDescriptionId, disabled: disabled, errorId: confirmationErrorId, fieldId: confirmationId, invalid: confirmationInvalid, onConfirmedChange: onConfirmedChange }), _jsx(Button, { className: "justify-self-start", disabled: disabled, onClick: () => onEmergencyChange(false), type: "button", variant: "ghost", children: "Use standard feedback instead" })] }));
+}
+function FeedbackEmergencyEntry({ disabled, onEmergencyChange, }) {
+    return (_jsxs("div", { className: "border-t pt-(--panel-gap)", children: [_jsxs(Button, { className: "w-full justify-start text-destructive hover:text-destructive", disabled: disabled, onClick: () => onEmergencyChange(true), type: "button", variant: "outline", children: [_jsx(AlertTriangleIcon, {}), "Report an emergency"] }), _jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: "Use this when service or time-sensitive work is blocked and the team needs to respond now." })] }));
+}
+function FeedbackEmergencyNotice() {
+    return (_jsxs(Alert, { variant: "destructive", children: [_jsx(AlertTriangleIcon, {}), _jsx(AlertTitle, { children: "Emergency feedback" }), _jsx(AlertDescription, { children: "This follows the same support workflow, with an urgent priority and an immediate notification to the configured response team." })] }));
+}
+function FeedbackAffectedScopeField({ affectedScope, affectedScopeId, disabled, onAffectedScopeChange, }) {
+    return (_jsxs(Field, { children: [_jsx(FieldContent, { children: _jsx(FieldLabel, { htmlFor: affectedScopeId, required: true, children: "Who is affected?" }) }), _jsxs(Select, { disabled: disabled, onValueChange: (value) => {
+                    if (isAffectedScope(value))
+                        onAffectedScopeChange(value);
+                }, value: affectedScope, children: [_jsx(SelectTrigger, { "aria-required": "true", className: "w-full", id: affectedScopeId, children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: "just_me", children: "Just me" }), _jsx(SelectItem, { value: "my_team", children: "My team" }), _jsx(SelectItem, { value: "everyone", children: "Everyone" }), _jsx(SelectItem, { value: "unknown", children: "I'm not sure" })] })] })] }));
+}
+function FeedbackEmergencyConfirmation({ confirmed, descriptionId, disabled, errorId, fieldId, invalid, onConfirmedChange, }) {
+    const describedBy = invalid ? `${descriptionId} ${errorId}` : descriptionId;
+    return (_jsxs(Field, { "data-invalid": invalid, orientation: "horizontal", children: [_jsx(Checkbox, { "aria-describedby": describedBy, "aria-invalid": invalid, "aria-required": "true", checked: confirmed, disabled: disabled, id: fieldId, onCheckedChange: (checked) => onConfirmedChange(checked === true) }), _jsxs("div", { className: "grid gap-1", children: [_jsx(FieldLabel, { htmlFor: fieldId, required: true, children: "This needs an immediate response" }), _jsx(FieldDescription, { id: descriptionId, children: "I understand this will notify the configured emergency response team." }), invalid ? (_jsx(FieldError, { id: errorId, children: "Confirm that this needs an immediate response before sending." })) : null] })] }));
+}
+function isAffectedScope(value) {
+    return ["everyone", "just_me", "my_team", "unknown"].includes(value);
+}
+export { FeedbackEmergencyFields };

package/dist/components/blocks/feedback-metrics.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { MetricsStrip, MetricsStripDetail, MetricsStripItem, MetricsStripLabel, MetricsStripValue, } from "../ui/metrics-strip";
 function FeedbackMetricsStrip({ metrics }) {
-    return (_jsxs(MetricsStrip, { className: "md:grid-cols-5", children: [_jsx(FeedbackMetricItem, { detail: "New this week", label: "Received", tone: "neutral", value: metrics.receivedThisWeek }), _jsx(FeedbackMetricItem, { detail: "Needs review", label: "Awaiting review", tone: "warning", value: metrics.awaitingReview }), _jsx(FeedbackMetricItem, { detail: "Reviewed this week", label: "Triaged", tone: "info", value: metrics.triagedThisWeek }), _jsx(FeedbackMetricItem, { detail: "Active work", label: "In progress", tone: "info", value: metrics.inProgress }), _jsx(FeedbackMetricItem, { detail: "This week", label: "Resolved", tone: "success", value: metrics.resolvedThisWeek })] }));
+    return (_jsxs(MetricsStrip, { className: "md:grid-cols-3 xl:grid-cols-5", children: [_jsx(FeedbackMetricItem, { detail: "Visible tickets", label: "Total", tone: "neutral", value: metrics.total }), _jsx(FeedbackMetricItem, { detail: "Awaiting triage", label: "Received", tone: "warning", value: metrics.received }), _jsx(FeedbackMetricItem, { detail: "Active work", label: "In progress", tone: "info", value: metrics.inProgress }), _jsx(FeedbackMetricItem, { detail: "Needs a decision", label: "Discussion required", tone: "warning", value: metrics.discussionRequired }), _jsx(FeedbackMetricItem, { detail: "Finished", label: "Completed", tone: "success", value: metrics.completed })] }));
 }
 function FeedbackMetricItem({ detail, label, tone, value, }) {
     return (_jsxs(MetricsStripItem, { children: [_jsx(MetricsStripLabel, { children: label }), _jsx(MetricsStripValue, { children: value }), _jsx(MetricsStripDetail, { className: feedbackMetricToneClasses[tone], children: detail })] }));

package/dist/components/blocks/feedback-sheet.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { type FeedbackComposerProps } from "./feedback-composer";
-type FeedbackSheetProps = Omit<FeedbackComposerProps, "actions" | "formId" | "onCancel" | "onSubmittedChange"> & {
+type FeedbackSheetProps = Omit<FeedbackComposerProps, "actions" | "formId" | "onCancel" | "onDirtyChange" | "onSubmittedChange" | "onUrgencyChange"> & {
     onOpenChange: (open: boolean) => void;
     open: boolean;
 };

package/dist/components/blocks/feedback-sheet.js

@@ -1,16 +1,29 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as React from "react";
-import { SendIcon } from "lucide-react";
+import { AlertTriangleIcon, SendIcon } from "lucide-react";
 import { FeedbackComposer } from "./feedback-composer";
 import { Button } from "../ui/button";
-import { Sheet, SheetBody, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, } from "../ui/sheet";
+import { FormSheet, useFormSheetActions } from "../ui/form-sheet";
+import { SheetBody, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, } from "../ui/sheet";
 function FeedbackSheet({ onOpenChange, open, ...composerProps }) {
+    const [isDirty, setIsDirty] = React.useState(false);
+    React.useEffect(() => {
+        if (!open)
+            setIsDirty(false);
+    }, [open]);
+    return (_jsx(FormSheet, { closeDisabled: composerProps.isSubmitting ?? false, isDirty: isDirty, onOpenChange: onOpenChange, open: open, children: _jsx(FeedbackSheetContent, { composerProps: composerProps, onDirtyChange: setIsDirty, open: open }) }));
+}
+function FeedbackSheetContent({ composerProps, onDirtyChange, open, }) {
+    const { requestClose } = useFormSheetActions();
     const formId = React.useId();
     const [isSubmitted, setIsSubmitted] = React.useState(false);
+    const [urgency, setUrgency] = React.useState("normal");
     React.useEffect(() => {
-        if (!open)
+        if (!open) {
             setIsSubmitted(false);
+            setUrgency("normal");
+        }
     }, [open]);
-    return (_jsx(Sheet, { onOpenChange: onOpenChange, open: open, children: _jsxs(SheetContent, { size: "md", children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: "Send feedback" }), _jsx(SheetDescription, { children: "Share a bug, feature request, or general note." })] }), _jsx(SheetBody, { children: _jsx(FeedbackComposer, { ...composerProps, actions: "external", formId: formId, onCancel: () => onOpenChange(false), onSubmittedChange: setIsSubmitted }) }), isSubmitted ? null : (_jsxs(SheetFooter, { children: [_jsx(Button, { disabled: composerProps.isSubmitting, onClick: () => onOpenChange(false), type: "button", variant: "outline", children: "Cancel" }), _jsxs(Button, { form: formId, loading: composerProps.isSubmitting, type: "submit", children: [_jsx(SendIcon, {}), "Submit feedback"] })] }))] }) }));
+    return (_jsxs(SheetContent, { size: "md", children: [_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: "Send feedback" }), _jsx(SheetDescription, { children: "Share a bug, feature request, or general note." })] }), _jsx(SheetBody, { children: _jsx(FeedbackComposer, { ...composerProps, actions: "external", formId: formId, onCancel: requestClose, onDirtyChange: onDirtyChange, onSubmittedChange: setIsSubmitted, onUrgencyChange: setUrgency }) }), isSubmitted ? null : (_jsxs(SheetFooter, { children: [_jsx(Button, { disabled: composerProps.isSubmitting, onClick: requestClose, type: "button", variant: "outline", children: "Cancel" }), _jsxs(Button, { form: formId, loading: composerProps.isSubmitting, type: "submit", variant: urgency === "emergency" ? "destructive" : "default", children: [urgency === "emergency" ? _jsx(AlertTriangleIcon, {}) : _jsx(SendIcon, {}), urgency === "emergency" ? "Send emergency" : "Submit feedback"] })] }))] }));
 }
 export { FeedbackSheet };

package/dist/components/blocks/feedback-status-badge.js

@@ -5,10 +5,10 @@ function FeedbackStatusBadge({ status }) {
     return _jsx(Badge, { variant: feedbackStatusVariants[status], children: feedbackStatusLabels[status] });
 }
 const feedbackStatusVariants = {
+    completed: "success",
+    discussion_required: "warning",
     in_progress: "info",
-    in_review: "warning",
-    planned: "info",
+    no_action: "secondary",
     received: "outline",
-    resolved: "success",
 };
 export { FeedbackStatusBadge };

package/dist/components/blocks/feedback-table-row.js

@@ -1,25 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { PaperclipIcon } from "lucide-react";
+import { AlertTriangleIcon, MessageCircleMoreIcon } from "lucide-react";
 import { formatFeedbackTimestamp, getFeedbackTimestampDateTime } from "./feedback-date-format";
 import { FeedbackStatusBadge } from "./feedback-status-badge";
 import { FeedbackTypeBadge } from "./feedback-type-badge";
 import { getFeedbackInitials } from "./feedback-tracking-types";
 import { Avatar, AvatarFallback, AvatarImage } from "../ui/avatar";
+import { Badge } from "../ui/badge";
+import { Button } from "../ui/button";
 import { TableCell, TableRow } from "../ui/table";
 function FeedbackTableRow({ item, onSelectFeedback, }) {
-    return (_jsxs(TableRow, { className: onSelectFeedback ? "cursor-pointer" : undefined, onClick: () => onSelectFeedback?.(item), onKeyDown: (event) => {
-            if (!onSelectFeedback)
-                return;
-            if (event.currentTarget !== event.target)
-                return;
-            if (event.key !== "Enter" && event.key !== " ")
-                return;
-            event.preventDefault();
-            onSelectFeedback(item);
-        }, role: onSelectFeedback ? "button" : undefined, tabIndex: onSelectFeedback ? 0 : undefined, children: [_jsx(TableCell, { className: "max-w-[22rem]", children: _jsx(FeedbackSummaryCell, { item: item }) }), _jsx(TableCell, { children: _jsx(FeedbackTypeBadge, { type: item.type }) }), _jsx(TableCell, { children: _jsx(FeedbackSubmitterCell, { item: item }) }), _jsx(TableCell, { children: _jsx(FeedbackStatusBadge, { status: item.status }) }), _jsx(TableCell, { children: _jsx(FeedbackDateValue, { value: item.submittedAt }) }), _jsx(TableCell, { children: _jsx(FeedbackDateValue, { value: item.updatedAt }) }), _jsx(TableCell, { className: "text-right", children: _jsx(FeedbackAttachmentCount, { item: item }) })] }));
+    return (_jsxs(TableRow, { className: onSelectFeedback ? "cursor-pointer focus-within:bg-muted/60" : undefined, onClick: () => onSelectFeedback?.(item), children: [_jsx(TableCell, { className: "max-w-[22rem]", children: onSelectFeedback ? (_jsx(Button, { "aria-label": `Open feedback: ${item.subject}`, className: "h-auto w-full justify-start p-0 text-left whitespace-normal hover:bg-transparent", onClick: (event) => {
+                        event.stopPropagation();
+                        onSelectFeedback(item);
+                    }, type: "button", variant: "ghost", children: _jsx(FeedbackSummaryCell, { item: item }) })) : (_jsx(FeedbackSummaryCell, { item: item })) }), _jsx(TableCell, { children: _jsx(FeedbackTypeBadge, { type: item.type }) }), _jsx(TableCell, { children: _jsx(FeedbackSubmitterCell, { item: item }) }), _jsx(TableCell, { children: _jsx(FeedbackStatusBadge, { status: item.status }) }), _jsx(TableCell, { children: _jsx(FeedbackDateValue, { value: item.submittedAt }) }), _jsx(TableCell, { children: _jsx(FeedbackDateValue, { value: item.updatedAt }) })] }));
 }
 function FeedbackSummaryCell({ item }) {
-    return (_jsxs("div", { className: "min-w-0", children: [_jsx("div", { className: "truncate text-sm font-medium text-foreground", children: item.subject }), _jsx("div", { className: "truncate text-xs text-muted-foreground", children: item.description })] }));
+    return (_jsxs("span", { className: "grid min-w-0 gap-1", children: [_jsxs("span", { className: "flex min-w-0 items-center gap-2", children: [_jsx("span", { className: "truncate text-sm font-medium text-foreground", children: item.subject }), item.urgency === "emergency" ? (_jsxs(Badge, { variant: "destructive", children: [_jsx(AlertTriangleIcon, {}), "Emergency"] })) : null, item.hasUnreadCustomerReply ? (_jsxs(Badge, { variant: "secondary", children: [_jsx(MessageCircleMoreIcon, {}), "Customer replied"] })) : null] }), _jsx("span", { className: "truncate text-xs text-muted-foreground", children: item.description }), _jsx("span", { className: "font-mono text-xs text-muted-foreground tabular-nums", children: item.referenceId ?? item.id })] }));
 }
 function FeedbackSubmitterCell({ item }) {
     const submitter = item.submittedBy;
@@ -28,10 +24,4 @@ function FeedbackSubmitterCell({ item }) {
 function FeedbackDateValue({ value }) {
     return (_jsx("time", { className: "font-mono text-xs text-muted-foreground tabular-nums", dateTime: getFeedbackTimestampDateTime(value), children: formatFeedbackTimestamp(value) }));
 }
-function FeedbackAttachmentCount({ item }) {
-    const count = item.attachments?.length ?? 0;
-    if (count === 0)
-        return _jsx("span", { className: "text-xs text-muted-foreground", children: "None" });
-    return (_jsxs("span", { className: "inline-flex items-center justify-end gap-1 font-mono text-xs text-muted-foreground tabular-nums", children: [_jsx(PaperclipIcon, { className: "size-3.5" }), count] }));
-}
 export { FeedbackTableRow };

package/dist/components/blocks/feedback-table-sort.js

@@ -67,11 +67,11 @@ const defaultFeedbackTableSort = {
     key: "submittedAt",
 };
 const statusSortOrder = {
-    in_progress: 3,
-    in_review: 1,
-    planned: 2,
+    completed: 3,
+    discussion_required: 2,
+    in_progress: 1,
+    no_action: 4,
     received: 0,
-    resolved: 4,
 };
 const typeSortOrder = {
     bug: 0,

package/dist/components/blocks/feedback-table.js

@@ -24,7 +24,7 @@ function FeedbackTable({ defaultSort = defaultFeedbackTableSort, emptyAction, em
     return (_jsx(DataTable, { children: _jsx(DataTableContent, { children: _jsx(FeedbackTableContent, { items: sortedItems, onSelectFeedback: onSelectFeedback, onSortChange: handleSortChange, sort: activeSort }) }) }));
 }
 function FeedbackTableLoading() {
-    return (_jsx(DataTable, { children: _jsx(DataTableSkeleton, { columns: 7, rows: 6 }) }));
+    return (_jsx(DataTable, { children: _jsx(DataTableSkeleton, { columns: 6, rows: 6 }) }));
 }
 function FeedbackTableEmpty({ action, description, title, }) {
     return (_jsx(DataTable, { children: _jsx(DataTableEmpty, { className: "min-h-80 border-b-0", children: _jsx(FeedbackTableEmptyContent, { action: action, description: description, title: title }) }) }));
@@ -36,7 +36,7 @@ function FeedbackTableContent({ items, onSelectFeedback, onSortChange, sort, })
     return (_jsxs(Table, { children: [_jsx(FeedbackTableHeader, { onSortChange: onSortChange, sort: sort }), _jsx(TableBody, { children: items.map((item) => (_jsx(FeedbackTableRow, { item: item, onSelectFeedback: onSelectFeedback }, item.id))) })] }));
 }
 function FeedbackTableHeader({ onSortChange, sort, }) {
-    return (_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { children: "Feedback" }), _jsx(FeedbackSortableHead, { label: "Type", onSortChange: onSortChange, sort: sort, sortKey: "type" }), _jsx(FeedbackSortableHead, { label: "Submitted by", onSortChange: onSortChange, sort: sort, sortKey: "submittedBy" }), _jsx(FeedbackSortableHead, { label: "Status", onSortChange: onSortChange, sort: sort, sortKey: "status" }), _jsx(FeedbackSortableHead, { label: "Submitted", onSortChange: onSortChange, sort: sort, sortKey: "submittedAt" }), _jsx(FeedbackSortableHead, { label: "Updated", onSortChange: onSortChange, sort: sort, sortKey: "updatedAt" }), _jsx(TableHead, { className: "text-right", children: "Files" })] }) }));
+    return (_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { children: "Feedback" }), _jsx(FeedbackSortableHead, { label: "Type", onSortChange: onSortChange, sort: sort, sortKey: "type" }), _jsx(FeedbackSortableHead, { label: "Submitted by", onSortChange: onSortChange, sort: sort, sortKey: "submittedBy" }), _jsx(FeedbackSortableHead, { label: "Status", onSortChange: onSortChange, sort: sort, sortKey: "status" }), _jsx(FeedbackSortableHead, { label: "Submitted", onSortChange: onSortChange, sort: sort, sortKey: "submittedAt" }), _jsx(FeedbackSortableHead, { label: "Updated", onSortChange: onSortChange, sort: sort, sortKey: "updatedAt" })] }) }));
 }
 function FeedbackSortableHead({ label, onSortChange, sort, sortKey, }) {
     const active = sort.key === sortKey;

package/dist/components/blocks/feedback-tracking-types.d.ts

@@ -1,5 +1,8 @@
-type FeedbackStatus = "received" | "in_review" | "planned" | "in_progress" | "resolved";
+declare const feedbackStatusValues: readonly ["received", "in_progress", "discussion_required", "completed", "no_action"];
+type FeedbackStatus = (typeof feedbackStatusValues)[number];
 type StakeholderFeedbackType = "bug" | "feature" | "general";
+type FeedbackUrgency = "emergency" | "normal";
+type FeedbackAffectedScope = "everyone" | "just_me" | "my_team" | "unknown";
 type FeedbackSubmittedBy = {
     email?: string;
     imageUrl?: string;
@@ -11,8 +14,10 @@ type FeedbackAttachment = {
     url?: string;
 };
 type StakeholderFeedbackItem = {
+    affectedScope?: FeedbackAffectedScope;
     attachments?: FeedbackAttachment[];
     description: string;
+    hasUnreadCustomerReply?: boolean;
     id: string;
     referenceId?: string;
     status: FeedbackStatus;
@@ -21,24 +26,28 @@ type StakeholderFeedbackItem = {
     submittedBy: FeedbackSubmittedBy;
     type: StakeholderFeedbackType;
     updatedAt?: string;
+    urgency?: FeedbackUrgency;
 };
 type UserFeedbackItem = {
+    affectedScope?: FeedbackAffectedScope;
     attachments?: FeedbackAttachment[];
     description: string;
+    hasUnreadReply?: boolean;
     id: string;
-    referenceId?: string;
     status: FeedbackStatus;
     subject: string;
     submittedAt: string;
     type: StakeholderFeedbackType;
+    unreadReplyCount?: number;
     updatedAt?: string;
+    urgency?: FeedbackUrgency;
 };
 type FeedbackMetrics = {
-    awaitingReview: number;
+    completed: number;
+    discussionRequired: number;
     inProgress: number;
-    receivedThisWeek: number;
-    resolvedThisWeek: number;
-    triagedThisWeek: number;
+    received: number;
+    total: number;
 };
 declare const feedbackStatusLabels: Record<FeedbackStatus, string>;
 declare const feedbackTypeLabels: Record<StakeholderFeedbackType, string>;
@@ -50,16 +59,16 @@ declare const feedbackStatusOptions: readonly [{
     readonly value: "received";
 }, {
     readonly label: string;
-    readonly value: "in_review";
+    readonly value: "in_progress";
 }, {
     readonly label: string;
-    readonly value: "planned";
+    readonly value: "discussion_required";
 }, {
     readonly label: string;
-    readonly value: "in_progress";
+    readonly value: "completed";
 }, {
     readonly label: string;
-    readonly value: "resolved";
+    readonly value: "no_action";
 }];
 declare const feedbackTypeOptions: readonly [{
     readonly label: "All types";
@@ -75,4 +84,4 @@ declare const feedbackTypeOptions: readonly [{
     readonly value: "general";
 }];
 declare function getFeedbackInitials(name: string, email: string | undefined): string;
-export { feedbackStatusLabels, feedbackStatusOptions, feedbackTypeLabels, feedbackTypeOptions, getFeedbackInitials, type FeedbackAttachment, type FeedbackMetrics, type FeedbackStatus, type FeedbackSubmittedBy, type StakeholderFeedbackItem, type StakeholderFeedbackType, type UserFeedbackItem, };
+export { feedbackStatusLabels, feedbackStatusOptions, feedbackStatusValues, feedbackTypeLabels, feedbackTypeOptions, getFeedbackInitials, type FeedbackAffectedScope, type FeedbackAttachment, type FeedbackMetrics, type FeedbackStatus, type FeedbackSubmittedBy, type FeedbackUrgency, type StakeholderFeedbackItem, type StakeholderFeedbackType, type UserFeedbackItem, };

package/dist/components/blocks/feedback-tracking-types.js

@@ -1,9 +1,17 @@
+// The canonical status list, in triage order; the union derives from it.
+const feedbackStatusValues = [
+    "received",
+    "in_progress",
+    "discussion_required",
+    "completed",
+    "no_action",
+];
 const feedbackStatusLabels = {
+    completed: "Completed",
+    discussion_required: "Discussion required",
     in_progress: "In progress",
-    in_review: "In review",
-    planned: "Planned",
+    no_action: "No action",
     received: "Received",
-    resolved: "Resolved",
 };
 const feedbackTypeLabels = {
     bug: "Bug",
@@ -13,10 +21,10 @@ const feedbackTypeLabels = {
 const feedbackStatusOptions = [
     { label: "All statuses", value: "all" },
     { label: feedbackStatusLabels.received, value: "received" },
-    { label: feedbackStatusLabels.in_review, value: "in_review" },
-    { label: feedbackStatusLabels.planned, value: "planned" },
     { label: feedbackStatusLabels.in_progress, value: "in_progress" },
-    { label: feedbackStatusLabels.resolved, value: "resolved" },
+    { label: feedbackStatusLabels.discussion_required, value: "discussion_required" },
+    { label: feedbackStatusLabels.completed, value: "completed" },
+    { label: feedbackStatusLabels.no_action, value: "no_action" },
 ];
 const feedbackTypeOptions = [
     { label: "All types", value: "all" },
@@ -33,4 +41,4 @@ function getFeedbackInitials(name, email) {
         .map((part) => part.charAt(0).toUpperCase())
         .join("");
 }
-export { feedbackStatusLabels, feedbackStatusOptions, feedbackTypeLabels, feedbackTypeOptions, getFeedbackInitials, };
+export { feedbackStatusLabels, feedbackStatusOptions, feedbackStatusValues, feedbackTypeLabels, feedbackTypeOptions, getFeedbackInitials, };

package/dist/components/blocks/feedback-type-badge.js

@@ -5,7 +5,7 @@ function FeedbackTypeBadge({ type }) {
     return _jsx(Badge, { variant: feedbackTypeVariants[type], children: feedbackTypeLabels[type] });
 }
 const feedbackTypeVariants = {
-    bug: "destructive",
+    bug: "warning",
     feature: "info",
     general: "outline",
 };

package/dist/components/blocks/feedback-user-detail.d.ts

@@ -3,8 +3,9 @@ import type { UserFeedbackItem } from "./feedback-tracking-types";
 type FeedbackUserDetailProps = {
     activityLabel?: string;
     activitySlot?: React.ReactNode;
+    evidenceSlot?: React.ReactNode;
     feedback?: UserFeedbackItem;
     onBack?: () => void;
 };
-declare function FeedbackUserDetail({ activityLabel, activitySlot, feedback, onBack, }: FeedbackUserDetailProps): React.JSX.Element;
+declare function FeedbackUserDetail({ activityLabel, activitySlot, evidenceSlot, feedback, onBack, }: FeedbackUserDetailProps): React.JSX.Element;
 export { FeedbackUserDetail, type FeedbackUserDetailProps };