@lovett/ui 0.2.0 → 0.2.3

package/dist/index.d.ts

@@ -7378,6 +7378,16 @@ interface ThreadReactionCount {
  * ADR-147 D17 — optimistic send is a first-class state, not a nicety.
  * A comment silently lost to a bad connection is the worst thing this surface
  * can do to someone, and it is the most likely.
+ *
+ * `pending` AND `failed` ARE VIEWER-LOCAL, and that is an invariant a host has
+ * to hold rather than a thing this type can enforce. Both describe a comment
+ * that has not landed: it exists in one browser, no other viewer can see it,
+ * and no read should ever return either value. A host that puts `failed` on a
+ * row it fetched is describing somebody ELSE's comment as the viewer's own
+ * failed send, and the retry drawn beside it — the one control on this surface
+ * with no capability flag, because it never needed one — becomes the same lie
+ * `canEdit` exists to stop. Absent means `sent`, which is what every read
+ * should leave it as.
  */
 type CommentDeliveryState = 'sent' | 'pending' | 'failed';
 /**
@@ -7493,6 +7503,91 @@ interface ThreadComment {
      * sees a word change.
      */
     readonly moderated?: boolean | undefined;
+    /**
+     * Whether to DRAW the edit control on THIS comment.
+     *
+     * 0.2.0 forwarded `onEdit` and `onDelete` through to the thread and gated
+     * both menu items on nothing but "a callback exists, and this is not a
+     * tombstone". There was no authorship check anywhere in the render, so a
+     * host that wired the two mutations drew them on every live comment,
+     * including the ones the viewer did not write. Every server this was pointed
+     * at refused correctly, which is exactly what makes it the wrong kind of
+     * bug. It is not a hole; it is a LIE. A menu item that exists and can never
+     * work tells somebody they may do a thing they may not, and it is worse than
+     * the absent item, because the absent item at least agrees with the server.
+     *
+     * TWO flags rather than one `viewerIsAuthor`, and the argument for the
+     * second one is already in this interface. `moderated` exists because a
+     * comment can be removed by somebody OTHER than its author (FU-0031,
+     * FU-0032) — so a surface that can produce that tombstone has a delete
+     * predicate that is NOT authorship, while its edit stays author-only. This
+     * module cannot say what any host's predicates ARE, and does not try to; it
+     * only has to be able to spell two that differ, and `moderated` is already
+     * proof that they do. One consumer's arrangement is the existence proof
+     * rather than the rule: a moderated delete on a route of its own behind an
+     * admin rank, and the author-gated edit deliberately left alone, because the
+     * rank that removes somebody's words is not the rank that rewrites them.
+     * A single `viewerIsAuthor` cannot express that pair, and the day it has to,
+     * the fix is a breaking rename rather than a field.
+     *
+     * (Naming a consumer here is a narrower act than the one the TOMBSTONE
+     * docblock in `comment.tsx` rules out. That one would have told every host
+     * how to DERIVE a value — a schema stated as this module's fact. This one
+     * cites an arrangement to show a shape is reachable, and constrains nobody:
+     * a host whose two predicates are identical sets both flags the same way and
+     * never notices the seam has two halves.)
+     *
+     * A per-comment field rather than a predicate in the render context, because
+     * `ThreadLinkPreview.canHide` is already that shape and a second shape for
+     * the same idea is a second thing to learn. It also means nothing between
+     * here and the control needs new plumbing: `<Thread>` and `<ActivityPane>`
+     * forward `comments` verbatim, so the capability arrives with the row it
+     * describes.
+     *
+     * The SHAPE is `canHide`'s; the DEFAULT is its opposite, and that is worth
+     * saying out loud before somebody reasons from the precedent and guesses
+     * backwards. `canHide` is REQUIRED and therefore fails closed — a card whose
+     * host says nothing draws no dismiss control. These two are OPTIONAL and
+     * fail open. The difference is not principle, it is history: link previews
+     * were new when `canHide` landed, so requiring it cost no host anything,
+     * whereas edit and delete already render for everyone and a required field
+     * would be a breaking change that silently removes controls until it is
+     * supplied. "ABSENT MEANS TRUE" below is the whole of that argument.
+     *
+     * Deriving it here from `author.id` against a viewer id was the other
+     * candidate and is rejected twice over: a derived rule recomputed on the
+     * client is a second copy waiting to disagree with the server's, and
+     * `author.id` is nullable by D5 — `ON DELETE SET NULL` would quietly turn
+     * "the author is gone" into "you wrote this".
+     *
+     * ABSENT MEANS TRUE, and that is the uncomfortable half of this. A host on
+     * 0.2.0 that wired `onEdit` and upgrades without touching its data keeps
+     * precisely the render it has today, defect included. The alternative —
+     * absent means false — fixes that host by silently taking the edit control
+     * off the viewer's OWN comments until it maps two new fields: a release in
+     * which nobody can edit anything, nothing errors, no test in the host fails,
+     * and it survives to production for the same reason FU-0019 did. Trading a
+     * known lie for a new silent regression is not a trade, so the default
+     * preserves the render and this docblock is the notice. The seam is one
+     * field wide; a host that means it should set it.
+     *
+     * RENDERING ONLY, and never an authorization decision — the same words
+     * `canHide` is written in, for the same reason. The server re-checks
+     * authorship on every edit and rank on every moderated delete; a client that
+     * flips this to `true` earns a 404, not an edit.
+     */
+    readonly canEdit?: boolean | undefined;
+    /**
+     * Whether to DRAW the delete control on THIS comment. Everything above
+     * applies, including that absent means true and that this decides RENDERING
+     * only — the server remains the gate and refuses on its own authority.
+     *
+     * It is separate from `canEdit` so the two predicates can differ, which on a
+     * surface with moderation they already do: an admin may remove a comment
+     * they may not rewrite, so `canDelete: true` with `canEdit: false` is the
+     * shape that describes them and there is no way to spell it with one flag.
+     */
+    readonly canDelete?: boolean | undefined;
     readonly reactions?: readonly ThreadReactionCount[] | undefined;
     readonly attachments?: readonly ThreadAttachment[] | undefined;
     /**
@@ -7604,6 +7699,16 @@ interface ActivityPaneProps {
      * by opening the surface rather than by reading the source, and the source
      * understates it.
      *
+     * WIRING `onEdit` OR `onDelete` IS HALF THE JOB. The callback says the host
+     * has the mutation; `canEdit` / `canDelete` on each `ThreadComment` say
+     * whether this viewer may use it on THAT comment, and the pane forwards
+     * `comments` verbatim, so they arrive with no plumbing here. Set them, or
+     * every live comment in the feed gets an Edit the server will 404 — which is
+     * what forwarding these two without them shipped as, and the same shape as
+     * the `onHideLinkPreview` note below. Absent means the item is drawn, so
+     * nothing this pane renders today disappears on upgrade; that is a
+     * deliberate default and `ThreadComment` argues it.
+     *
      * `onRetry` is the same omission with one sharper edge: the failed send it
      * recovers was posted by THIS pane's own composer, so dropping it left the
      * pane manufacturing a state and offering nobody a way out of it.
@@ -8381,6 +8486,14 @@ interface ThreadRenderContext extends RichComposerAttachmentProps {
      */
     readonly onCopyLink?: ((commentId: string) => void) | undefined;
     readonly onCopyText?: ((commentId: string, ok: boolean) => void) | undefined;
+    /**
+     * Edit and delete are gated TWICE, and the second gate is the per-comment
+     * one: the callback here says the host wired the mutation, and `canEdit` /
+     * `canDelete` on the row say whether this viewer may use it on THAT comment
+     * (see `ThreadComment`). Wiring the callback alone draws the item on every
+     * live comment, which is what 0.2.0 did and what the server then refused.
+     * Absent flags keep the item, so nothing a 0.2.0 host draws disappears.
+     */
     readonly onEdit?: ((commentId: string) => void) | undefined;
     readonly onDelete?: ((commentId: string) => void) | undefined;
     /**

package/dist/index.js

@@ -1,5 +1,5 @@
-import { cn, composeRefs, useAnchoredPosition, useLayer, useOutsideClick, POPOVER_SURFACE_STYLE, __export, Input, Popover, handleTabTrap, Button, Kbd, usePrefersReducedMotion, QUIET_ICON_BOX, QUIET_ICON, RichThreadComposer, ThreadComposer, CommentBody, tabbablesWithin, AttachmentImage, AttachmentGif } from './chunk-RBYWGBQ2.js';
-export { ATTACHMENT_ACCEPT, ATTACHMENT_LIMITS, AttachmentButton, AttachmentDropZone, AttachmentGif, AttachmentImage, AttachmentLightbox, AttachmentPlaceholder, AttachmentTray, Button, CodeBlock, CommentBody, GIF_SEARCH_DEBOUNCE_MS, GifPicker, Input, Kbd, MarkdownCode, MarkdownRenderer, PASTE_ATTACHMENT_THRESHOLD, POPOVER_SURFACE_STYLE, Popover, RichThreadComposer, ThreadComposer, applyMarkdownFormat, cn, computeAnchoredPosition, formatAttachmentSize, parseMentionHref, pastedTextFilename, shouldAttachPaste, useAnchoredPosition, useAttachmentUrl, useAttachments, useEscapeKey, useLayer, useOutsideClick, usePrefersReducedMotion } from './chunk-RBYWGBQ2.js';
+import { cn, composeRefs, useAnchoredPosition, useLayer, useOutsideClick, POPOVER_SURFACE_STYLE, __export, Input, Popover, handleTabTrap, Button, Kbd, usePrefersReducedMotion, QUIET_ICON_BOX, QUIET_ICON, RichThreadComposer, ThreadComposer, CommentBody, tabbablesWithin, AttachmentImage, AttachmentGif } from './chunk-GP7BKVZC.js';
+export { ATTACHMENT_ACCEPT, ATTACHMENT_LIMITS, AttachmentButton, AttachmentDropZone, AttachmentGif, AttachmentImage, AttachmentLightbox, AttachmentPlaceholder, AttachmentTray, Button, CodeBlock, CommentBody, GIF_SEARCH_DEBOUNCE_MS, GifPicker, Input, Kbd, MarkdownCode, MarkdownRenderer, PASTE_ATTACHMENT_THRESHOLD, POPOVER_SURFACE_STYLE, Popover, RichThreadComposer, ThreadComposer, applyMarkdownFormat, cn, computeAnchoredPosition, formatAttachmentSize, parseMentionHref, pastedTextFilename, shouldAttachPaste, useAnchoredPosition, useAttachmentUrl, useAttachments, useEscapeKey, useLayer, useOutsideClick, usePrefersReducedMotion } from './chunk-GP7BKVZC.js';
 import React2, { forwardRef, Children, isValidElement, createContext, useContext, useId, useRef, useEffect, useMemo, useCallback, useState, useLayoutEffect, memo, useSyncExternalStore, cloneElement, Fragment as Fragment$1 } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { Minus, Check, ChevronDown, X, Loader2, Play, VolumeX, Volume2, ChevronUp, Link2, ChevronLeft, MoreHorizontal, ThumbsUp as ThumbsUp$1, MessageCircle, Share2, Search, Plus, ChevronRight, CircleX, CircleCheck, CircleSlash, CircleDotDashed, Circle, CircleDashed, Pencil, House, GripVertical, Folder, Flag, ImageOff, ChevronsUpDown, SlidersHorizontal, Copy, FolderClosed, FolderPlus, Paperclip, Upload, Image, Code, Table as Table$1, FileText, FileType, AlertCircle, RotateCcw, ArrowRight, ListFilter, ArrowLeft, ArrowDown, ArrowUp, Info, ChartLine, Table2, Inbox, TriangleAlert, ChevronsLeft, ChevronsUp, ChevronsRight, ChevronsDown, Star, Settings2, CornerDownRight, Trash2, SmilePlus, ArrowBigUp, ArrowBigDown, ExternalLink, RotateCw, MessageSquare, Lock, PanelRight, SquareDashed, Maximize2, Archive, Printer, Repeat2, CornerUpRight } from 'lucide-react';
@@ -24429,7 +24429,8 @@ var CHIP_BASE = cn(
   "inline-flex items-center justify-center gap-[var(--space-1)] border px-[var(--space-2)] text-[12px] font-semibold tabular-nums",
   "transition-[background-color,border-color,color,box-shadow,transform] duration-[var(--dur-fast)] ease-[var(--ease-out)]",
   "motion-reduce:transition-none",
-  "focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus)]",
+  // INSET: chips sit inside clipping ancestors on both hosts.
+  "focus-visible:outline-none focus-visible:[box-shadow:var(--ring-focus-inset)]",
   "active:scale-[0.96] motion-reduce:active:scale-100",
   "disabled:cursor-not-allowed disabled:opacity-60"
 );
@@ -25294,6 +25295,8 @@ function CommentItem({
   const author = node.author ?? null;
   const tint = asAvatarTint(author?.tint);
   const canEngage = !deleted && state === "sent";
+  const canEdit = ctx.onEdit !== void 0 && !deleted && node.canEdit !== false;
+  const canDelete = ctx.onDelete !== void 0 && !deleted && node.canDelete !== false;
   const indentClampDepth = ctx.indentClampDepth ?? DEFAULT_INDENT_CLAMP_DEPTH;
   const connected = renderDepth > 0;
   const clamped = renderDepth > indentClampDepth;
@@ -25428,12 +25431,12 @@ function CommentItem({
                           ctx.onCopyLink?.(node.id);
                         }
                       },
-                      ...ctx.onEdit === void 0 || deleted ? {} : {
+                      ...!canEdit ? {} : {
                         onEdit: () => {
                           ctx.onEdit?.(node.id);
                         }
                       },
-                      ...ctx.onDelete === void 0 || deleted ? {} : {
+                      ...!canDelete ? {} : {
                         onDelete: () => {
                           ctx.onDelete?.(node.id);
                         }