@orz/ui-content 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright 2026 the orzui team
+Copyright 2026 the todou team
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -1,3 +1,411 @@
-# Temporary Holding Version
+# @orz/ui-content
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A registry where content packages contribute renderers and from which any surface asks for content
+to be drawn. It is what lets markdown, code, diagrams and an attachment viewer render one another
+without importing one another: each of them peers on this package, and the app decides at runtime
+which renderers exist.
+
+## Install
+
+```bash
+pnpm add @orz/ui-content react
+```
+
+The root entry has no runtime dependencies and needs no CSS. Its fallbacks are a plain `<pre>` and
+a plain link, styled by whatever typography surrounds them. Attachment viewing, under
+`@orz/ui-content/attachment`, needs more; see [Attachments](#attachments).
+
+## The contract
+
+```ts
+type ContentSource =
+  | { kind: "inline"; text: string; lang?: string }
+  | {
+      kind: "file";
+      name: string;
+      mime?: string;
+      size?: number;
+      url?: string; // where the bytes live: an <img>, an <iframe>, the download link
+      load?: (signal: AbortSignal) => Promise<string>; // the text, for renderers that need it
+      deleted?: boolean; // links and embeds draw it struck through, as deleted
+    };
+
+type Placement = "document" | "viewer"; // inside a flow of content, or owning the surface
+
+type ContentRenderer = {
+  name: string;
+  accepts(source: ContentSource, placement: Placement): boolean;
+  display?: "block" | "inline"; // default "block"
+  Component: ComponentType<ContentProps & { Next: ComponentType<ContentProps> }>;
+};
+```
+
+`accepts` must be synchronous and pure, decided from the descriptor alone. Callers make layout
+decisions from it during render (a paragraph holding a block embed becomes a `<div>`), and those
+must not flip when data arrives later.
+
+## Registering and drawing
+
+```tsx
+import { Content, ContentRenderers, type ContentRenderer } from "@orz/ui-content";
+
+const shout: ContentRenderer = {
+  name: "shout",
+  accepts: (source) => source.kind === "inline" && source.lang === "shout",
+  Component: ({ source, className }) => (
+    <strong className={className}>
+      {source.kind === "inline" && source.text.toUpperCase()}
+    </strong>
+  ),
+};
+
+const framed: ContentRenderer = {
+  name: "framed",
+  accepts: (source) => source.kind === "file",
+  Component: ({ Next, ...props }) => (
+    <figure>
+      <Next {...props} />
+      <figcaption>{props.source.kind === "file" && props.source.name}</figcaption>
+    </figure>
+  ),
+};
+
+const renderers = [shout, framed];
+
+<ContentRenderers renderers={renderers}>
+  <Content source={{ kind: "inline", text: "hi", lang: "shout" }} placement="document" />
+</ContentRenderers>;
+```
+
+- **Order.** The list is ordered and the first renderer that accepts a source draws it, so a narrow
+  renderer goes before a broad one (markdown files before any text file). Renderers do not exclude
+  one another's kinds; the app's order decides.
+- **`Next`.** A renderer's `Next` draws the same source with the renderers after it, which is how a
+  frame wraps whatever would have drawn the file anyway. Past the end of the list comes the
+  fallback: `<pre><code>` for inline text, and a download link (or the bare name, when there is no
+  `url`) for a file. `ContentFallback` is the same fallback as a component, for a renderer that
+  decides to step aside.
+- **Nesting.** A nested `<ContentRenderers>` puts its renderers in front of the outer ones, so a
+  surface can override one kind locally.
+- **Stable lists.** Keep `renderers` a module constant or a memo. Each position's `Next` is built
+  once per list, so a renderer's subtree keeps its identity across re-renders. A new array rebuilds
+  them, and React remounts whatever the renderers drew, collapsing any live text selection inside.
+- **`className`** goes on the renderer's root element. A decoration pass that marked the element a
+  source was written as (an embedded `<img>`) needs that class to survive the swap.
+
+`useContentDisplay(source, placement)` answers `"block"`, `"inline"` or `null` (nothing registered
+accepts it) without rendering anything. `useContentDisplayOf()` returns the same question as a
+function, for a caller asking about several sources in one render.
+
+## Depth
+
+A file source drawn by a renderer raises `useContentDepth()` by one for everything below it, once
+per `<Content>`. A document that embeds documents reads its depth to stop recursing: past its limit
+it draws `ContentFallback`, a link, instead of the document. Inline sources never raise it, so a
+code fence inside an embedded document still renders.
+
+`<ContentRenderers maxDepth>` stores a limit for renderers to read with `useContentMaxDepth()`.
+`<Content>` does not enforce it; each renderer that recurses decides what its limit means.
+
+## Title bar
+
+A surface with a title bar of its own (a card, a dialog) can lend a spot in it to the renderer
+drawing its file, for controls that belong next to the surface's own:
+
+```tsx
+import { ContentTitleBar, useContentTitleBar } from "@orz/ui-content";
+
+// The surface: a spot in its bar, and the slot around its body.
+const [bar, setBar] = useState<HTMLElement | null>(null);
+<span ref={setBar} className="contents" />
+<ContentTitleBar source={file} target={bar}>
+  <Content source={file} placement="viewer" />
+</ContentTitleBar>
+
+// A renderer: portal the controls there, or draw a bar of its own.
+const bar = useContentTitleBar(source);
+if (bar === undefined) return <FramedWithOwnBar />;
+return <>{bar !== null && createPortal(controls, bar)}{body}</>;
+```
+
+`useContentTitleBar` returns the element, `null` while the bar is still mounting, or `undefined`
+when no surface lent one for this source. The slot is keyed by the source object, not by nesting:
+only the renderer drawing that exact source sees it, so a fence or an embed inside the file, being
+a source of its own, never takes over the surface's bar. `attachmentCard` lends its card's bar.
+
+## Loading text
+
+```tsx
+import { ContentFallback, useSourceText, type ContentProps } from "@orz/ui-content";
+
+function TextFile(props: ContentProps) {
+  const text = useSourceText(props.source);
+  if (text.status === "loading") return <ContentFallback {...props} />;
+  if (text.status === "error") {
+    return (
+      <p>
+        {text.error.message} <button onClick={text.retry}>Retry</button>
+      </p>
+    );
+  }
+  return <pre>{text.text}</pre>;
+}
+```
+
+Inline text is ready at once. A file calls `load` when it has one and fetches `url` otherwise, and
+the load is aborted on unmount and when the source changes; an aborted load is not reported as an
+error. `retry()` runs the load again.
+
+A file counts as changed when its `name` or `url` does, or, for a file with no `url`, when its `load`
+function does. Keep such a `load` stable. A `load` beside a `url` is read from the latest render, so
+a resolver building a fresh closure each render does not restart the load.
+
+Size caps are the caller's: check `size` before asking for the text.
+
+## File kinds
+
+```ts
+import { isImageFile, isTextFile, isMarkdownFile, formatSize } from "@orz/ui-content";
+
+isImageFile(f)  isTextFile(f)     isMarkdownFile(f)  isHtmlFile(f)
+isPdfFile(f)    isArchiveFile(f)  isAudioFile(f)     isVideoFile(f)
+isPatchFile(f)  // text/x-patch, text/x-diff, or .patch / .diff under a generic type
+isTextEmbed(f)  // a text file that is not also an image (.svg is both)
+formatSize(bytes) // "512 B", "1.5 KB", "20 KB"
+TEXT_PREVIEW_MAX_BYTES      // 1 MiB: text past this previews only when asked, and plain
+TEXT_PREVIEW_HARD_MAX_BYTES // 10 MiB: text past this never previews
+textPreviewGate({ name, mime?, size }, { max?, hardMax? }) // "auto" | "ask" | "refuse"
+```
+
+`textPreviewGate` is the rule the viewer and `attachmentCard` apply: a text file up to `max`
+previews on its own, one up to `hardMax` waits for "Preview anyway", and a larger one never
+previews. A patch skips the asking, since its view is drawn per file.
+
+Each predicate takes `{ name, mime? }`, so a file `ContentSource` passes straight in. A declared
+type outranks the filename: the extension only counts when `mime` is missing, empty or
+`application/octet-stream`. A `.png` declared `text/plain` is text, and a `.ts` uploaded as
+octet-stream is TypeScript, never an MPEG transport stream. `mime` is read without its parameters
+or case, so `Text/HTML; charset=utf-8` is `text/html`.
+
+Renderers use these in `accepts` rather than matching extensions of their own, so that every
+package draws the same file as the same kind.
+
+## Attachments
+
+`@orz/ui-content/attachment` draws files: renderers for images, HTML, PDF, video and audio, a frame
+for text files embedded in a document, one viewer dialog, and the links and lists that open it. It
+peers on `@orz/ui`, `lucide-react` and `react-dom` as well:
+
+```bash
+pnpm add @orz/ui-content @orz/ui lucide-react react react-dom
+```
+
+```css
+@import "tailwindcss";
+@import "@orz/ui/styles.css";
+@import "@orz/ui-content/styles.css"; /* after @orz/ui's; only when ./attachment is used */
+```
+
+The stylesheet registers the package's shipped JS with Tailwind, so the classes the attachment
+components use are generated.
+
+### Registering the renderers
+
+```tsx
+import { ContentRenderers } from "@orz/ui-content";
+import {
+  AttachmentViewerProvider,
+  attachmentCard,
+  audioContent,
+  htmlContent,
+  imageContent,
+  pdfContent,
+  videoContent,
+} from "@orz/ui-content/attachment";
+
+const RENDERERS = [
+  attachmentCard(),
+  imageContent(),
+  htmlContent(),
+  pdfContent(),
+  videoContent(),
+  audioContent(),
+  mermaidContent,
+  markdownContent(),
+  patchContent,
+  codeContent,
+];
+
+<ContentRenderers renderers={RENDERERS}>
+  <AttachmentViewerProvider viewHref={viewHref} group={group}>
+    <App />
+  </AttachmentViewerProvider>
+</ContentRenderers>;
+```
+
+The order matters, because the first renderer that accepts a source draws it:
+
+- **`attachmentCard` first**, so a text file embedded in a document is framed before anything draws
+  it. It hands the file on through `Next`, and the renderers after it draw the frame's body.
+- **Images before text**, because an `.svg` is both, and it should be drawn as an image.
+- **Markdown and diagrams before a renderer that takes every text file**, or that renderer would
+  draw them as source.
+
+| Renderer | Accepts | Placement | Draws |
+|---|---|---|---|
+| `attachmentCard({ maxBytes?, maxDepth?, collapsedClassName? })` | text files that are not images | `document` | `DocumentCard` around `Next` |
+| `imageContent()` | images with a `url` | both | `<img>`; in a document, a click opens the viewer; in the viewer, a zoomable canvas |
+| `htmlContent({ src? })` | HTML with a `url` | `viewer` | `<iframe sandbox="allow-scripts">` |
+| `pdfContent({ src? })` | PDF with a `url` | `viewer` | `<iframe>`, unsandboxed |
+| `videoContent()` | video with a `url` | both | `VideoPlayer`; in a document, under a header with the name and Download |
+| `audioContent()` | audio with a `url` | both | `AudioPlayer`; in a document, under a header with the file's icon, name and Download |
+
+A file with no `url` is never accepted by the binary renderers, and falls through to the
+registry's fallback. In a document an HTML file is text, so `attachmentCard` frames its source; a
+PDF embed is the fallback's download link.
+
+**Never add `allow-same-origin` to the HTML frame.** A file served from the app's own origin could
+then run scripts that call the app's API with the reader's cookies. `allow-scripts` alone keeps the
+document on an opaque origin. The PDF frame carries no sandbox because Chromium's PDF viewer refuses
+to run in a sandboxed frame, so serve PDFs from a URL that cannot be mistaken for the app.
+
+A video or audio file the browser cannot play (an `.avi`, a `.wma`) falls through to the renderers
+after `videoContent`/`audioContent`, usually the download link, with "This browser can't play this
+file." under it.
+
+### Video and audio players
+
+`VideoPlayer` and `AudioPlayer` are the players the renderers draw, for use on their own: a native
+`<video>`/`<audio>` without native controls, an optional `header` above, and `MediaControls` from
+`@orz/ui` underneath.
+
+```tsx
+import { VideoPlayer } from "@orz/ui-content/attachment";
+
+<VideoPlayer
+  src={url}
+  title="clip.webm"
+  header={<MyHeader />}
+  onError={() => setUnplayable(true)}
+/>;
+```
+
+- Props: `src`, `title` (the accessible name and the frame's `title`), `header`, `autoPlay`,
+  `loop`, `speed` (the initial speed) and `className`. The video preloads metadata only.
+- `onError` is called when the element cannot load or decode `src`, and the player then draws
+  nothing; without it, the player says "This browser can't play this file." in place of the
+  picture (for audio, the bar).
+- A video adds picture-in-picture and fullscreen where the document offers them. Fullscreen takes
+  the whole frame, so the bar stays.
+- Keys, anywhere in the frame unless the focused control uses the key itself (a slider its arrows,
+  a button Space): Space or `k` plays and pauses, ← → seek 5 s, `0`–`9` jump to tenths of the
+  duration, `m` mutes, `f` toggles fullscreen. A handled key is `preventDefault()`ed, so inside the
+  viewer an arrow key on the focused picture seeks rather than paging.
+
+`attachmentCard`:
+
+- past the depth limit (`maxDepth`, else the provider's `maxDepth`, else 1, counted as
+  `markdownContent` counts it) it draws an `AttachmentLink` chip instead of a frame, so a document
+  inside a card shows its own documents as links;
+- over `maxBytes` (default `TEXT_PREVIEW_MAX_BYTES`, 1 MiB) it draws the frame with "Large files
+  aren't previewed automatically." and a Preview anyway button, then the body once asked (a patch
+  is not asked about); over `hardMaxBytes` (default `TEXT_PREVIEW_HARD_MAX_BYTES`, 10 MiB) it draws
+  the frame with a note and no body. A file of unknown size is not capped here; the renderer `Next`
+  reaches decides once the text is loaded (`codeContent` draws text over 1 MiB without
+  highlighting);
+- otherwise it draws the frame with the size, a download button and, inside a provider, an expand
+  button that opens the viewer. Loading and load errors are drawn by the renderer `Next` reaches,
+  which may also put controls in the frame's title bar (`useContentTitleBar`).
+
+### The viewer
+
+```ts
+<AttachmentViewerProvider
+  viewHref={(file) => string | undefined}   // where a browser tab shows the file
+  group={(file) => ({ items, index }) | null} // the set paging covers when one file is opened
+  textPreviewMaxBytes={1024 * 1024}          // text above this waits for "Preview anyway"
+  textPreviewHardMaxBytes={10 * 1024 * 1024} // text above this never previews
+  imageLook={{ background, smoothing }}      // controlled image look; default: held in memory
+  onImageLookChange={(look) => void}
+>
+
+useAttachmentViewer(): { open(items, index), show(file) } | null  // null outside a provider
+useCanPreview(file): boolean   // whether a plain click should open the viewer
+useViewHref(file): string      // viewHref(file) ?? file.url ?? ""
+useStoredImageLook(storageKey): [ImageLook, (look: ImageLook) => void]
+```
+
+One provider owns one dialog, and everything below it opens that one. A nested provider shadows
+the outer one, so a surface can page through its own set.
+
+- **`viewHref`** is for an app that serves a separate inline-view URL beside the download URL.
+  Anchors, the HTML and PDF frames and "Open in new tab" use it; Download always uses `url`. When it
+  returns undefined, "Open in new tab" is left out.
+- **`group`** lets a click on one file page through the set it belongs to, positioned on it. A file
+  it returns null for opens alone.
+- **`useCanPreview`** is true when some registered renderer accepts the file in `"viewer"`
+  placement and, for a text file, its size is known. A text file over `textPreviewMaxBytes` opens
+  on "Large files aren't previewed automatically." with Preview anyway, which holds until the
+  viewer pages away; one over `textPreviewHardMaxBytes` opens on "This file is too large to
+  preview.", with the footer's Download. A patch is not asked about. HTML is not capped: the
+  browser streams it into the frame rather than this tab drawing it as text. HTML that no frame
+  takes (no `htmlContent`, or no `url`) reaches the text renderers, which apply their own cap. `attachmentCard` draws
+  its expand button only when this holds.
+
+The dialog shows the name, ‹ n / m › for a set (← and → page, wrapping), a maximize toggle that
+fills the window and stays a modal, and the close button, all in one row. Its body is `<Content placement="viewer">`, or a download pane
+for a file nothing can draw. The body sets `--attachment-pane-height` (`75vh`, or the remaining
+height when maximized); a renderer in `"viewer"` placement sizes to it, as in
+`max-h-(--attachment-pane-height)`. The title bar lends the renderer drawing the file a slot
+between the name and the pager, through `ContentTitleBar`, for controls of its own.
+`AttachmentViewer` is the same dialog, controlled, for an app that holds `{ items, index } | null`
+itself, and takes the same `imageLook` props.
+
+An image in the viewer sits on a canvas. The wheel zooms about the pointer, as do a trackpad pinch
+(ctrl+wheel, or Safari's gesture events) and a two-finger pinch on a phone; dragging pans once
+zoomed; a click toggles between fit and actual pixels (or twice the fit, if that is deeper) at the
+pointer. Zoom runs from fit, or 100% if that is smaller, to 8× natural pixels, and panning never
+pulls an image edge inside the canvas. Restored, fit never enlarges an image; maximized, it fills
+the window. Paging starts every image at fit; maximize keeps the zoom and the point at the centre.
+Restored, the canvas asks for the image's height at its zoom, so zooming in grows the dialog up to
+the pane's height before it pans, and the height tweens as it changes (not under
+`prefers-reduced-motion`). While the mouse is over the zoom controls or ‹ ›, the canvas keeps the
+height it had when the pointer arrived, so the controls do not slide out from under it; it lets go
+400 ms after the pointer leaves, or at once on a key, a press or a wheel.
+
+In the title bar, − and + step the zoom (hidden on a phone, where pinch does it), and the readout
+opens a menu: Fit (key `0`), 100% (key `1`), a black or checkerboard background, and smooth or
+pixelated scaling. `+` `-` `0` `1` work from the keyboard; with Ctrl/⌘ they stay the browser's page
+zoom. Black fills the canvas; the checkerboard sits under the image only, so an opaque image looks
+the same and a transparent one shows where it ends. Pixelated applies only above 100%. An image that
+fails to load is a plain `<img>`, with no controls.
+
+The background and scaling (`ImageLook`, default checkerboard and smooth) are the viewer's, not
+the image's, so paging and reopening keep them. Without `imageLook` the viewer holds them in memory
+until the page reloads. `useStoredImageLook(storageKey)` keeps them in localStorage and follows
+other tabs; hand its pair to `imageLook` and `onImageLookChange`, and name the key after the app.
+
+### Links, lists, cards and icons
+
+- **`<AttachmentLink file boxed? className?>`** is an inline link wearing the file's type icon. It is
+  a real anchor to `useViewHref(file)`, so copy-link and middle-click work; a plain left click on a
+  file `useCanPreview` accepts opens the viewer. `boxed` draws it as a bordered chip. It is a
+  `LinkChip` from `@orz/ui/components/link-chip`, which also exports the chip's classes. A file
+  marked `deleted` is its name struck through, with no link.
+- **`<AttachmentList items actions? title? id? className?>`** lists files (`FileSource` plus a
+  `key` and an optional ISO `createdAt`) with their icon, size, time and a download button.
+  `actions(item)` draws the app's own controls at the end of a row, such as a delete button. A list
+  of eight or more keeps its newest five rows and folds the rest behind a toggle. A plain click on a
+  row opens the viewer on the whole list. An empty list renders nothing.
+- **`<DeletedAttachmentMark name className?>`** is what a document shows for a link or embed of a
+  deleted file: the name struck through, with the word "deleted". `@orz/ui-markdown`'s
+  `attachmentLinks` and `markdownEmbeds` draw it for a file their `resolve` marks `deleted`.
+- **`<DocumentCard name icon? meta? headerActions? titleBarFor? downloadUrl? onExpand? collapsedClassName?>`**
+  is the frame `attachmentCard` draws, for anything else that wants it: a header with the name, a
+  muted note, extra actions, download and expand, around a height-capped body that offers "Show full
+  document" when it overflows. Without `onExpand` it draws no expand controls. With `titleBarFor`,
+  it lends a spot in the header, after the name, to the renderer drawing that source.
+- **`fileIcon(file)`** is the lucide icon for a file's kind: image, HTML, patch, text, archive,
+  audio, video, else a generic file.
+
+`@orz/ui-markdown`'s `attachmentLinks` plugin draws markdown links to files as `AttachmentLink`s.

package/dist/attachment/card-content.d.ts

@@ -0,0 +1,26 @@
+import type { ContentRenderer } from "../types.ts";
+export type AttachmentCardOptions = {
+    /**
+     * Text files above this wait for "Preview anyway", and the renderer then draws them plain.
+     * Default 1 MiB.
+     */
+    maxBytes?: number;
+    /** Text files above this draw a note instead of their contents. Default 10 MiB. */
+    hardMaxBytes?: number;
+    /**
+     * How many embedded files deep a card is still drawn; past it, the file is a link chip.
+     * Defaults to the provider's `maxDepth`, else 1, as `markdownContent` counts it, so the two
+     * agree on which level turns into a link.
+     */
+    maxDepth?: number;
+    /** Height cap for the card's collapsed body. Default `max-h-80`. */
+    collapsedClassName?: string;
+};
+/**
+ * Frames a text file embedded in a document: a `DocumentCard` whose body is drawn by the
+ * renderers after this one. Register it first, so a text embed is framed before anything draws it.
+ *
+ * Returns a new renderer on every call, so call it once, where the renderer list is built.
+ */
+export declare function attachmentCard(options?: AttachmentCardOptions): ContentRenderer;
+//# sourceMappingURL=card-content.d.ts.map

package/dist/attachment/card-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"card-content.d.ts","sourceRoot":"","sources":["../../src/attachment/card-content.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,aAAa,CAAC;AASjE,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,GAAE,qBAA0B,GAClC,eAAe,CAgFjB"}

package/dist/attachment/card-content.js

@@ -0,0 +1,49 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { formatSize, isTextEmbed, textPreviewGate } from "../file-kind.js";
+import { useContentDepth, useContentMaxDepth } from "../registry.js";
+import { DocumentCard } from "./document-card.js";
+import { AttachmentLink } from "./link.js";
+import { useAttachmentViewer, useCanPreview, } from "./viewer.js";
+/**
+ * Frames a text file embedded in a document: a `DocumentCard` whose body is drawn by the
+ * renderers after this one. Register it first, so a text embed is framed before anything draws it.
+ *
+ * Returns a new renderer on every call, so call it once, where the renderer list is built.
+ */
+export function attachmentCard(options = {}) {
+    const limits = { max: options.maxBytes, hardMax: options.hardMaxBytes };
+    function AttachmentCard({ source, className, Next, }) {
+        const depth = useContentDepth();
+        const providerMaxDepth = useContentMaxDepth();
+        const viewer = useAttachmentViewer();
+        const canPreview = useCanPreview(source);
+        const [asked, setAsked] = useState(false);
+        if (source.kind !== "file")
+            return null;
+        const maxDepth = options.maxDepth ?? providerMaxDepth ?? 1;
+        // A document inside a document card shows its own documents as links,
+        // which is what stops a document that embeds itself.
+        if (depth > maxDepth) {
+            return _jsx(AttachmentLink, { file: source, className: className });
+        }
+        const meta = source.size === undefined ? undefined : formatSize(source.size);
+        const gate = source.size === undefined
+            ? "auto"
+            : textPreviewGate({ ...source, size: source.size }, limits);
+        if (gate === "refuse" || (gate === "ask" && !asked)) {
+            return (_jsx(DocumentCard, { name: source.name, meta: meta, downloadUrl: source.url, className: className, collapsedClassName: options.collapsedClassName, children: _jsx("p", { className: "text-sm text-muted-foreground", children: gate === "refuse" ? ("This file is too large to preview.") : (_jsxs(_Fragment, { children: ["Large files aren't previewed automatically.", " ", _jsx("button", { type: "button", onClick: () => setAsked(true), className: "cursor-pointer font-medium text-foreground hover:underline", children: "Preview anyway" })] })) }) }));
+        }
+        return (_jsx(DocumentCard, { name: source.name, meta: meta, downloadUrl: source.url, titleBarFor: source, 
+            // Only when the viewer would draw it: a text file of unknown size
+            // would open on the download pane.
+            onExpand: viewer !== null && canPreview ? () => viewer.show(source) : undefined, className: className, collapsedClassName: options.collapsedClassName, children: _jsx(Next, { source: source, placement: "document" }) }));
+    }
+    return {
+        name: "attachment-card",
+        accepts: (source, placement) => source.kind === "file" && placement === "document" && isTextEmbed(source),
+        display: "block",
+        Component: AttachmentCard,
+    };
+}
+//# sourceMappingURL=card-content.js.map

package/dist/attachment/card-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"card-content.js","sourceRoot":"","sources":["../../src/attachment/card-content.tsx"],"names":[],"mappings":"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"}

package/dist/attachment/deleted.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Where a document links or embeds a file that was deleted: the name it was linked under, struck
+ * through, with the word a broken image would otherwise leave the reader to guess.
+ */
+export declare function DeletedAttachmentMark({ name, className, }: {
+    name: string;
+    className?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=deleted.d.ts.map

package/dist/attachment/deleted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted.d.ts","sourceRoot":"","sources":["../../src/attachment/deleted.tsx"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,SAAS,GACV,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,+BAcA"}

package/dist/attachment/deleted.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@orz/ui/lib/utils";
+import { FileXIcon } from "lucide-react";
+/**
+ * Where a document links or embeds a file that was deleted: the name it was linked under, struck
+ * through, with the word a broken image would otherwise leave the reader to guess.
+ */
+export function DeletedAttachmentMark({ name, className, }) {
+    return (_jsxs("span", { className: cn("inline-flex items-center gap-1 rounded border border-dashed px-1.5 text-sm text-muted-foreground", className), "data-attachment-deleted": "", children: [_jsx(FileXIcon, { "aria-hidden": true, className: "size-3.5 shrink-0" }), _jsx("span", { className: "line-through", children: name }), _jsx("span", { children: "deleted" })] }));
+}
+//# sourceMappingURL=deleted.js.map

package/dist/attachment/deleted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted.js","sourceRoot":"","sources":["../../src/attachment/deleted.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACpC,IAAI,EACJ,SAAS,GAIV;IACC,OAAO,CACL,gBACE,SAAS,EAAE,EAAE,CACX,kGAAkG,EAClG,SAAS,CACV,6BACuB,EAAE,aAE1B,KAAC,SAAS,yBAAa,SAAS,EAAC,mBAAmB,GAAG,EACvD,eAAM,SAAS,EAAC,cAAc,YAAE,IAAI,GAAQ,EAC5C,qCAAoB,IACf,CACR,CAAC;AACJ,CAAC"}

package/dist/attachment/document-card.d.ts

@@ -0,0 +1,32 @@
+import { type ComponentType, type ReactNode } from "react";
+import type { ContentSource } from "../types.ts";
+export type DocumentCardProps = {
+    name: string;
+    /** Default: `fileIcon({ name })`. */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Short muted note next to the name (e.g. a size). */
+    meta?: ReactNode;
+    /** Extra header controls, rendered before download/expand. */
+    headerActions?: ReactNode;
+    /**
+     * The source the body draws, when its renderer may put controls in the header
+     * (`useContentTitleBar`). They sit after the name, before `headerActions`.
+     */
+    titleBarFor?: ContentSource;
+    downloadUrl?: string;
+    /** Opens the full document; without it the card draws no expand controls. */
+    onExpand?: () => void;
+    /** Height cap for the collapsed body. */
+    collapsedClassName?: string;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * A bordered card with a filename header and a height-capped body. Generic on
+ * purpose: an attachment embed puts the drawn file in it, and an app can put
+ * anything else there, with version chips or review state in `headerActions`.
+ */
+export declare function DocumentCard({ name, icon, meta, headerActions, titleBarFor, downloadUrl, onExpand, collapsedClassName, className, children, }: DocumentCardProps): import("react").JSX.Element;
+//# sourceMappingURL=document-card.d.ts.map

package/dist/attachment/document-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-card.d.ts","sourceRoot":"","sources":["../../src/attachment/document-card.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,IAAI,CAAC,EAAE,aAAa,CAAC;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7C,uDAAuD;IACvD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,WAAW,EACX,WAAW,EACX,QAAQ,EACR,kBAA+B,EAC/B,SAAS,EACT,QAAQ,GACT,EAAE,iBAAiB,+BA4GnB"}

package/dist/attachment/document-card.js

@@ -0,0 +1,38 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@orz/ui/lib/utils";
+import { DownloadIcon, Maximize2Icon } from "lucide-react";
+import { useEffect, useRef, useState, } from "react";
+import { ContentTitleBar } from "../title-bar.js";
+import { fileIcon } from "./icon.js";
+/**
+ * A bordered card with a filename header and a height-capped body. Generic on
+ * purpose: an attachment embed puts the drawn file in it, and an app can put
+ * anything else there, with version chips or review state in `headerActions`.
+ */
+export function DocumentCard({ name, icon, meta, headerActions, titleBarFor, downloadUrl, onExpand, collapsedClassName = "max-h-80", className, children, }) {
+    const outerRef = useRef(null);
+    const innerRef = useRef(null);
+    const [overflowing, setOverflowing] = useState(false);
+    const [titleBar, setTitleBar] = useState(null);
+    // The cap sits on the outer box, so growth of the inner content (lazy
+    // code block upgrade, images loading) never resizes the observed border
+    // box — observe the inner one.
+    useEffect(() => {
+        const outer = outerRef.current;
+        const inner = innerRef.current;
+        if (outer === null || inner === null)
+            return;
+        const check = () => setOverflowing(inner.offsetHeight > outer.clientHeight + 1);
+        check();
+        if (typeof ResizeObserver === "undefined")
+            return;
+        const observer = new ResizeObserver(check);
+        observer.observe(inner);
+        return () => observer.disconnect();
+    }, []);
+    const Icon = icon ?? fileIcon({ name });
+    const title = (_jsxs(_Fragment, { children: [_jsx(Icon, { className: "size-4 shrink-0 text-muted-foreground" }), _jsx("span", { className: cn("truncate font-medium", onExpand && "hover:underline"), children: name }), meta !== undefined && (_jsx("span", { className: "shrink-0 text-xs text-muted-foreground", children: meta }))] }));
+    return (_jsxs("section", { className: cn("my-2 overflow-hidden rounded-lg border", className), children: [_jsxs("div", { className: "flex items-center gap-1 border-b bg-muted/40 py-1 pr-1.5 pl-3 text-sm", children: [onExpand ? (_jsx("button", { type: "button", onClick: onExpand, className: "flex min-w-0 flex-1 cursor-pointer items-center gap-2 text-left", children: title })) : (_jsx("span", { className: "flex min-w-0 flex-1 items-center gap-2 py-1", children: title })), titleBarFor !== undefined && (_jsx("span", { ref: setTitleBar, className: "contents" })), headerActions, downloadUrl !== undefined && (_jsx("a", { href: downloadUrl, download: name, "aria-label": `download ${name}`, className: "rounded-md p-1.5 text-muted-foreground hover:bg-muted hover:text-foreground", children: _jsx(DownloadIcon, { className: "size-3.5" }) })), onExpand && (_jsx("button", { type: "button", onClick: onExpand, "aria-label": `expand ${name}`, className: "cursor-pointer rounded-md p-1.5 text-muted-foreground hover:bg-muted hover:text-foreground", children: _jsx(Maximize2Icon, { className: "size-3.5" }) }))] }), _jsxs("div", { ref: outerRef, className: cn("relative overflow-hidden", collapsedClassName), children: [_jsx("div", { ref: innerRef, className: "p-3", children: titleBarFor === undefined ? (children) : (_jsx(ContentTitleBar, { source: titleBarFor, target: titleBar, children: children })) }), overflowing &&
+                        (onExpand ? (_jsx("button", { type: "button", onClick: onExpand, className: "absolute inset-x-0 bottom-0 flex h-16 cursor-pointer items-end justify-center bg-gradient-to-t from-background to-transparent pb-1.5 text-xs font-medium text-muted-foreground hover:text-foreground", children: "Show full document" })) : (_jsx("div", { className: "pointer-events-none absolute inset-x-0 bottom-0 h-16 bg-gradient-to-t from-background to-transparent" })))] })] }));
+}
+//# sourceMappingURL=document-card.js.map

package/dist/attachment/document-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-card.js","sourceRoot":"","sources":["../../src/attachment/document-card.tsx"],"names":[],"mappings":"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"}