@joewinke/jatui 0.36.3 → 0.38.0

package/dist/artifact-blocks/BlockRenderer.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { BlocksSpec, HostAdapter } from "./types.js";
+interface Props {
+    spec: BlocksSpec;
+    artifactId: string;
+    version: number;
+    /** This viewer's saved per-block state: blockId → its saved blob. */
+    savedBlocks?: Record<string, unknown> | null;
+    /**
+     * Persist the WHOLE per-block state map (debounced here). Omit on a
+     * read-only surface — blocks then get ctx.saveState === undefined. The
+     * renderer owns the merge: it posts its current map (the touched block's
+     * new state plus every other block's latest), so a host page can POST it
+     * verbatim and never hold a stale copy.
+     */
+    onSaveBlock?: (payload: {
+        kind: "blocks";
+        blocks: Record<string, unknown>;
+    }) => Promise<void>;
+    /** True on the public share route — blocks must not show viewer chrome. */
+    readonly?: boolean;
+    /** Live data published for the artifact; {} when none. */
+    data?: Record<string, unknown>;
+    /** Save-status changes, for the host page's header indicator. */
+    onStatus?: (status: "idle" | "saving" | "saved" | "failed") => void;
+    /**
+     * Per-block comment threads (mos-kib2f). Undefined on the read-only
+     * share surface — blocks render with no viewer chrome, per the contract.
+     */
+    comments?: {
+        enabled: boolean;
+        /** Unresolved counts per block (server-rendered). */
+        counts: Record<string, number>;
+    };
+    /**
+     * Per-block approve / needs-a-pass / note (mos-wywa3): on for a page
+     * linked to a jat task, where "Finish review" answers that task. Each
+     * verdict saves under the block's `review:<blockId>` key.
+     */
+    review?: boolean;
+    /** Every change to the local state map, for the host's Finish review. */
+    onLocalChange?: (blocks: Record<string, unknown>) => void;
+    /**
+     * The host's services (comments, composer, listen, block services…).
+     * Omit inside BlocksArtifactView (it provides its own); set it when
+     * mounting the renderer alone.
+     */
+    adapter?: HostAdapter;
+}
+declare const BlockRenderer: import("svelte").Component<Props, {
+    revealBlock: (blockId: string) => boolean;
+    flush: () => Promise<void>;
+    failedSaveBlocks: () => string[];
+}, "">;
+type BlockRenderer = ReturnType<typeof BlockRenderer>;
+export default BlockRenderer;

package/dist/artifact-blocks/BlockVerdict.svelte

@@ -0,0 +1,151 @@
+<script lang="ts">
+  /**
+   * BlockVerdict (origin mos-wywa3) — the per-block approve / needs-a-pass /
+   * note strip a review page shows under each block that takes a verdict.
+   *
+   * Pure chrome: it renders the saved verdict and hands every change to the
+   * renderer, which saves it under the block's reserved `review:<blockId>`
+   * key (review.ts). Nothing here talks to the network. The verdicts are
+   * drafts until the viewer presses "Finish review", which sends them as ONE
+   * answer to the linked task.
+   *
+   * The verdict is jatui VerdictControl at size xs, the same control every
+   * review block uses — a repeat press of the active verdict does nothing;
+   * clearing is the explicit Undo. The note survives an Undo. The note is
+   * the host's composer (NoteComposer → HostAdapter.composer).
+   */
+  import VerdictControl from "../components/review/VerdictControl.svelte"
+  import type { VerdictOption } from "../actions/reviewKeys"
+  import NoteComposer from "./NoteComposer.svelte"
+  import type { BlockReviewState, NoteAttachment } from "./types.js"
+
+  type Verdict = NonNullable<BlockReviewState["verdict"]>
+  const VERDICTS: VerdictOption[] = [
+    { id: "approved", label: "Approve", tone: "success", key: "a" },
+    {
+      id: "needs-pass",
+      label: "Needs a pass",
+      tone: "warning",
+      key: "x",
+      opensNote: true,
+    },
+  ]
+
+  interface Props {
+    /** The artifact this page serves — the composer's upload leg targets it. */
+    artifactId: string
+    blockId: string
+    blockLabel: string
+    saved: BlockReviewState | null
+    /** Undefined on a surface that cannot save: the strip renders disabled. */
+    onChange?: (next: BlockReviewState) => void
+  }
+
+  let {
+    artifactId,
+    blockId,
+    blockLabel,
+    saved,
+    onChange = undefined,
+  }: Props = $props()
+
+  const verdict = $derived(saved?.verdict ?? null)
+  let noteOpen = $state(false)
+  let draft = $state("")
+  /** The note's attachments — descriptors of clips the host already stored. */
+  let clips = $state<NoteAttachment[]>([])
+  $effect(() => {
+    draft = saved?.note ?? ""
+  })
+  $effect(() => {
+    clips = saved?.attachments ?? []
+  })
+  const hasNote = $derived(Boolean(saved?.note) || clips.length > 0)
+
+  /** VerdictControl only calls this with a NEW verdict, never the active one. */
+  function setVerdict(next: Verdict) {
+    if (!onChange) return
+    const out: BlockReviewState = { verdict: next }
+    if (saved?.note) out.note = saved.note
+    if (clips.length) out.attachments = clips
+    onChange(out)
+    if (next === "needs-pass" && !saved?.note) noteOpen = true
+  }
+
+  function undoVerdict() {
+    if (!onChange) return
+    const out: BlockReviewState = {}
+    if (saved?.note) out.note = saved.note
+    if (clips.length) out.attachments = clips
+    onChange(out)
+  }
+
+  /** Save the note text + its current attachments (the composer's clip
+   * change fires it; blur flushes a pending text edit). */
+  function saveNote(text: string, nextClips: NoteAttachment[]) {
+    if (!onChange) return
+    const note = text.trim().slice(0, 2000)
+    if (
+      note === (saved?.note ?? "") &&
+      JSON.stringify(nextClips) === JSON.stringify(saved?.attachments ?? [])
+    )
+      return
+    const out: BlockReviewState = {}
+    if (verdict) out.verdict = verdict
+    if (note) out.note = note
+    if (nextClips.length) out.attachments = nextClips
+    onChange(out)
+  }
+</script>
+
+<div
+  class="border-base-content/10 mt-2 flex flex-wrap items-center gap-2 border-t pt-2"
+  role="group"
+  aria-label={`Your verdict on ${blockLabel}`}
+  data-block-verdict={blockId}
+>
+  <VerdictControl
+    options={VERDICTS}
+    value={verdict}
+    size="xs"
+    label={`Verdict on ${blockLabel}`}
+    undoLabel="Undo"
+    disabled={!onChange}
+    onVerdict={(v) => setVerdict(v as Verdict)}
+    onUndo={undoVerdict}
+  />
+  <button
+    type="button"
+    class="btn btn-xs btn-ghost rounded-field"
+    aria-expanded={noteOpen}
+    aria-controls={`verdict-note-${blockId}`}
+    disabled={!onChange}
+    onclick={() => (noteOpen = !noteOpen)}
+  >
+    {hasNote ? "Edit note" : "Add note"}
+  </button>
+  {#if hasNote && !noteOpen}
+    <span class="text-base-content/60 min-w-0 flex-1 truncate text-xs">
+      “{saved?.note}”
+    </span>
+  {/if}
+  {#if noteOpen}
+    <div id={`verdict-note-${blockId}`} class="w-full">
+      <!-- The ONE composer: whatever the host's composer offers (MOS: voice /
+           video / screen capture, file picker, paste and drag-drop). Saving
+           rides the draft-until-Finish semantics — no submit row here. -->
+      <NoteComposer
+        {artifactId}
+        bind:text={draft}
+        bind:clips
+        onClipsChange={(next) => saveNote(draft, next)}
+        onBlur={() => saveNote(draft, clips)}
+        rows={2}
+        maxLength={2000}
+        placeholder="What should change?"
+        label={`Note on ${blockLabel}`}
+        autofocus
+      />
+    </div>
+  {/if}
+</div>

package/dist/artifact-blocks/BlockVerdict.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { BlockReviewState } from "./types.js";
+interface Props {
+    /** The artifact this page serves — the composer's upload leg targets it. */
+    artifactId: string;
+    blockId: string;
+    blockLabel: string;
+    saved: BlockReviewState | null;
+    /** Undefined on a surface that cannot save: the strip renders disabled. */
+    onChange?: (next: BlockReviewState) => void;
+}
+declare const BlockVerdict: import("svelte").Component<Props, {}, "">;
+type BlockVerdict = ReturnType<typeof BlockVerdict>;
+export default BlockVerdict;