@wtfalch/threads 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Tallis Falch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin/copy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The one design problem a package with tables has in this estate: migrations
+ * are hand-written SQL, numbered per app, applied by psql on boot, additive.
+ * A package cannot own a number in an app's sequence. So it does not try:
+ * this copies any migration the app has not yet copied into the app's
+ * `drizzle/` as the next numbers, and records which in a small manifest. The
+ * diff shows the SQL, the app's own migrate script applies it, and the
+ * integration tier that applies every file to an empty Postgres catches a bad
+ * one first, as it does for the app's own.
+ */
+export declare const MANIFEST = ".threads-migrations.json";
+export interface Manifest {
+    /** package file name -> the name it was copied to in the app */
+    copied: Record<string, string>;
+}
+export interface CopyResult {
+    copied: Array<{
+        from: string;
+        to: string;
+    }>;
+    manifest: Manifest;
+}
+export declare function copyMigrations(opts: {
+    /** The package's migrations directory. */
+    from: string;
+    /** The app's migrations directory, `drizzle/` by convention. */
+    to: string;
+    /** Stamped into the header of each copied file. */
+    version?: string;
+}): CopyResult;
+export declare function describe(result: CopyResult): string;

package/dist/bin/copy.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+/**
+ * The one design problem a package with tables has in this estate: migrations
+ * are hand-written SQL, numbered per app, applied by psql on boot, additive.
+ * A package cannot own a number in an app's sequence. So it does not try:
+ * this copies any migration the app has not yet copied into the app's
+ * `drizzle/` as the next numbers, and records which in a small manifest. The
+ * diff shows the SQL, the app's own migrate script applies it, and the
+ * integration tier that applies every file to an empty Postgres catches a bad
+ * one first, as it does for the app's own.
+ */
+export const MANIFEST = '.threads-migrations.json';
+const NUMBERED = /^(\d{4})_(.+\.sql)$/;
+function readManifest(dir) {
+    const file = join(dir, MANIFEST);
+    if (!existsSync(file))
+        return { copied: {} };
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    return { copied: parsed.copied ?? {} };
+}
+function nextNumber(dir) {
+    let max = -1;
+    for (const name of readdirSync(dir)) {
+        const m = NUMBERED.exec(name);
+        if (m?.[1])
+            max = Math.max(max, Number(m[1]));
+    }
+    return max + 1;
+}
+export function copyMigrations(opts) {
+    mkdirSync(opts.to, { recursive: true });
+    const manifest = readManifest(opts.to);
+    const copied = [];
+    const sources = readdirSync(opts.from)
+        .filter((n) => NUMBERED.test(n))
+        .sort();
+    let next = nextNumber(opts.to);
+    for (const name of sources) {
+        if (manifest.copied[name])
+            continue;
+        const rest = NUMBERED.exec(name)?.[2] ?? name;
+        const target = `${String(next).padStart(4, '0')}_${rest}`;
+        const body = readFileSync(join(opts.from, name), 'utf8');
+        const header = `-- Copied from @wtfalch/threads${opts.version ? ` ${opts.version}` : ''} (migrations/${name}) by threads-migrations.\n-- Do not edit here; the next package version ships the next file.\n\n`;
+        writeFileSync(join(opts.to, target), header + body);
+        manifest.copied[name] = target;
+        copied.push({ from: name, to: target });
+        next += 1;
+    }
+    writeFileSync(join(opts.to, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`);
+    return { copied, manifest };
+}
+export function describe(result) {
+    if (result.copied.length === 0)
+        return 'threads-migrations: nothing to copy';
+    return result.copied.map((c) => `threads-migrations: ${c.from} -> ${basename(c.to)}`).join('\n');
+}

package/dist/bin/migrations.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migrations.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { copyMigrations, describe } from './copy.js';
+/**
+ * `threads-migrations [dir]` — copy this package's migrations the app has not
+ * yet copied into `dir` (default `drizzle`) as the next numbers. Idempotent;
+ * run it after every upgrade of @wtfalch/threads, then commit what it wrote.
+ */
+const here = dirname(fileURLToPath(import.meta.url));
+const from = join(here, '..', 'migrations');
+const to = resolve(process.cwd(), process.argv[2] ?? 'drizzle');
+let version;
+try {
+    version = JSON.parse(readFileSync(join(here, '..', '..', 'package.json'), 'utf8')).version;
+}
+catch {
+    version = undefined;
+}
+console.log(describe(copyMigrations({ from, to, version })));

package/dist/gates.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Who may read, write or moderate is the host's decision.
+ *
+ * The package decides nothing about it: every query and every action asks the
+ * three gates the host passed at mount, giving them the subject and the
+ * person, or nobody. The forum's defaults are one choice; a comment section
+ * under a private document is another; the package cannot tell them apart and
+ * must not try.
+ */
+/** What the session says about a person. The shape `@wtfalch/auth` returns, minus the claims. */
+export interface Who {
+    id: string;
+    name: string | null;
+    email: string | null;
+    emailVerified: boolean;
+}
+/** What a thread hangs off. A forum category is `{ kind: 'category', id: <category id> }`. */
+export interface Subject {
+    kind: string;
+    id: string;
+}
+export declare const CATEGORY = "category";
+export declare function categorySubject(categoryId: number | string): Subject;
+export type Gate = (subject: Subject, who: Who | null) => boolean | Promise<boolean>;
+export interface Gates {
+    /** May this person see the threads under this subject. */
+    read: Gate;
+    /** May this person post or comment under this subject. */
+    write: Gate;
+    /** May this person pin, lock, hide, move, set status, mute and ban here. */
+    moderate: Gate;
+}
+/**
+ * The forum's defaults: anyone reads, a person with a verified address
+ * writes, and moderation is whatever the app says, usually a role from its
+ * authz vocabulary. Nothing here is special to a category: an app that wants
+ * a public comment section under every page passes the same gates.
+ */
+export declare function forumGates(opts: {
+    moderate: (who: Who) => boolean | Promise<boolean>;
+}): Gates;
+export type ErrorCode = 'forbidden' | 'not_found' | 'locked' | 'standing' | 'rate_limited' | 'invalid';
+/** Every refusal the package makes, with a code the host can turn into a sentence. */
+export declare class ThreadsError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+export declare function isThreadsError(e: unknown): e is ThreadsError;

package/dist/gates.js

@@ -0,0 +1,38 @@
+/**
+ * Who may read, write or moderate is the host's decision.
+ *
+ * The package decides nothing about it: every query and every action asks the
+ * three gates the host passed at mount, giving them the subject and the
+ * person, or nobody. The forum's defaults are one choice; a comment section
+ * under a private document is another; the package cannot tell them apart and
+ * must not try.
+ */
+export const CATEGORY = 'category';
+export function categorySubject(categoryId) {
+    return { kind: CATEGORY, id: String(categoryId) };
+}
+/**
+ * The forum's defaults: anyone reads, a person with a verified address
+ * writes, and moderation is whatever the app says, usually a role from its
+ * authz vocabulary. Nothing here is special to a category: an app that wants
+ * a public comment section under every page passes the same gates.
+ */
+export function forumGates(opts) {
+    return {
+        read: () => true,
+        write: (_subject, who) => who?.emailVerified === true,
+        moderate: (_subject, who) => (who === null ? false : opts.moderate(who)),
+    };
+}
+/** Every refusal the package makes, with a code the host can turn into a sentence. */
+export class ThreadsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ThreadsError';
+        this.code = code;
+    }
+}
+export function isThreadsError(e) {
+    return e instanceof ThreadsError;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schema.js';
+export * from './gates.js';
+export * from './tree.js';
+export * from './threads.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './schema.js';
+export * from './gates.js';
+export * from './tree.js';
+export * from './threads.js';

package/dist/migrations/0001_threads.sql

@@ -0,0 +1,185 @@
+-- @wtfalch/threads 0001: the tables a forum, a feedback board and a comment
+-- section share. Copied into an app's drizzle/ sequence by
+-- `threads-migrations`, applied by the app's own migrate script. Hand-written,
+-- additive, one transaction per file, like everything else in the estate.
+--
+-- Every user-owned row keys by the issuer's user id (auth.wtfalch.dev): a
+-- string, never a uuid, never a foreign key to anything outside these tables.
+-- Who may read, write or moderate is the host's decision, passed in as gates;
+-- nothing here decides it, and there is no row-level security underneath.
+
+CREATE EXTENSION IF NOT EXISTS ltree;
+
+-- What this package knows about a person. Upserted on every write from the
+-- session (`seen`), so the name on a post follows the issuer rather than
+-- drifting. The email moves only once the issuer has verified it.
+CREATE TABLE IF NOT EXISTS "thread_people" (
+  "id" text PRIMARY KEY,
+  "name" text,
+  "email" text,
+  "standing" text NOT NULL DEFAULT 'ok' CHECK ("standing" IN ('ok', 'muted', 'banned')),
+  "last_seen_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "created_at" timestamp with time zone NOT NULL DEFAULT now()
+);
+
+-- A forum section. `kind` is the whole difference between a discussion board
+-- and a feedback board: feedback threads carry a status and take votes.
+CREATE TABLE IF NOT EXISTS "thread_categories" (
+  "id" bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  "slug" text NOT NULL UNIQUE,
+  "name" text NOT NULL,
+  "description" text,
+  "kind" text NOT NULL DEFAULT 'discussion' CHECK ("kind" IN ('discussion', 'feedback')),
+  "position" integer NOT NULL DEFAULT 0,
+  "created_at" timestamp with time zone NOT NULL DEFAULT now()
+);
+
+-- A thread hangs off a subject: a category (`subject_kind = 'category'`,
+-- `subject_id` the category id) or whatever the host names, with the host's
+-- id. A thread under a host subject has no title and no body of its own; the
+-- subject is the post, and there is exactly one such thread per subject.
+CREATE TABLE IF NOT EXISTS "threads" (
+  "id" bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  "subject_kind" text NOT NULL,
+  "subject_id" text NOT NULL,
+  "author_id" text REFERENCES "thread_people"("id"),
+  "title" text,
+  "slug" text,
+  "body" text,
+  "pinned" boolean NOT NULL DEFAULT false,
+  "locked" boolean NOT NULL DEFAULT false,
+  "hidden" boolean NOT NULL DEFAULT false,
+  "status" text CHECK ("status" IN ('open', 'planned', 'in_progress', 'done', 'declined')),
+  "duplicate_of" bigint REFERENCES "threads"("id"),
+  "comment_count" integer NOT NULL DEFAULT 0,
+  "vote_count" integer NOT NULL DEFAULT 0,
+  "last_activity_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "updated_at" timestamp with time zone NOT NULL DEFAULT now(),
+  CHECK ("subject_kind" <> 'category' OR "title" IS NOT NULL)
+);
+CREATE INDEX IF NOT EXISTS "threads_subject_idx"
+  ON "threads" ("subject_kind", "subject_id", "pinned" DESC, "last_activity_at" DESC);
+CREATE UNIQUE INDEX IF NOT EXISTS "threads_host_subject_idx"
+  ON "threads" ("subject_kind", "subject_id") WHERE "subject_kind" <> 'category';
+CREATE INDEX IF NOT EXISTS "threads_author_idx" ON "threads" ("author_id", "created_at");
+CREATE INDEX IF NOT EXISTS "threads_search_idx"
+  ON "threads" USING GIN (to_tsvector('simple', coalesce("title", '') || ' ' || coalesce("body", '')));
+
+-- A tree of any depth. `reply_to` is the parent; `path` is the chain of
+-- zero-padded ids from the top of the thread to this comment, so ordering by
+-- it walks the tree depth-first in creation order, and `path <@ x` is a
+-- subtree. The trigger below writes `path`, so no caller can get it wrong.
+CREATE TABLE IF NOT EXISTS "thread_comments" (
+  "id" bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  "thread_id" bigint NOT NULL REFERENCES "threads"("id") ON DELETE CASCADE,
+  "reply_to" bigint REFERENCES "thread_comments"("id"),
+  "path" ltree NOT NULL,
+  "author_id" text NOT NULL REFERENCES "thread_people"("id"),
+  "body" text NOT NULL,
+  "hidden" boolean NOT NULL DEFAULT false,
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "updated_at" timestamp with time zone NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS "thread_comments_thread_path_idx" ON "thread_comments" ("thread_id", "path");
+CREATE INDEX IF NOT EXISTS "thread_comments_path_gist_idx" ON "thread_comments" USING GIST ("path");
+CREATE INDEX IF NOT EXISTS "thread_comments_author_idx" ON "thread_comments" ("author_id", "created_at");
+
+CREATE OR REPLACE FUNCTION "thread_comments_path"() RETURNS trigger AS $$
+DECLARE
+  parent_path ltree;
+  parent_thread bigint;
+BEGIN
+  IF NEW."reply_to" IS NULL THEN
+    NEW."path" := text2ltree(lpad(NEW."id"::text, 12, '0'));
+  ELSE
+    SELECT "path", "thread_id" INTO parent_path, parent_thread
+      FROM "thread_comments" WHERE "id" = NEW."reply_to";
+    IF parent_path IS NULL THEN
+      RAISE EXCEPTION 'reply_to % does not exist', NEW."reply_to";
+    END IF;
+    IF parent_thread <> NEW."thread_id" THEN
+      RAISE EXCEPTION 'reply_to % is in thread %, not %', NEW."reply_to", parent_thread, NEW."thread_id";
+    END IF;
+    NEW."path" := parent_path || text2ltree(lpad(NEW."id"::text, 12, '0'));
+  END IF;
+  RETURN NEW;
+END $$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS "thread_comments_path_trg" ON "thread_comments";
+CREATE TRIGGER "thread_comments_path_trg"
+  BEFORE INSERT ON "thread_comments"
+  FOR EACH ROW EXECUTE FUNCTION "thread_comments_path"();
+
+-- Counts kept by trigger, so a list page never counts comments per row.
+CREATE OR REPLACE FUNCTION "thread_comments_count"() RETURNS trigger AS $$
+BEGIN
+  IF TG_OP = 'INSERT' THEN
+    UPDATE "threads"
+      SET "comment_count" = "comment_count" + 1, "last_activity_at" = NEW."created_at"
+      WHERE "id" = NEW."thread_id";
+    RETURN NEW;
+  ELSIF TG_OP = 'DELETE' THEN
+    UPDATE "threads" SET "comment_count" = "comment_count" - 1 WHERE "id" = OLD."thread_id";
+    RETURN OLD;
+  END IF;
+  RETURN NULL;
+END $$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS "thread_comments_count_trg" ON "thread_comments";
+CREATE TRIGGER "thread_comments_count_trg"
+  AFTER INSERT OR DELETE ON "thread_comments"
+  FOR EACH ROW EXECUTE FUNCTION "thread_comments_count"();
+
+-- One vote per person per thread. The action layer allows it in feedback
+-- categories only; the table does not know what a category is.
+CREATE TABLE IF NOT EXISTS "thread_votes" (
+  "thread_id" bigint NOT NULL REFERENCES "threads"("id") ON DELETE CASCADE,
+  "person_id" text NOT NULL REFERENCES "thread_people"("id"),
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  PRIMARY KEY ("thread_id", "person_id")
+);
+
+CREATE OR REPLACE FUNCTION "thread_votes_count"() RETURNS trigger AS $$
+BEGIN
+  IF TG_OP = 'INSERT' THEN
+    UPDATE "threads" SET "vote_count" = "vote_count" + 1 WHERE "id" = NEW."thread_id";
+    RETURN NEW;
+  ELSIF TG_OP = 'DELETE' THEN
+    UPDATE "threads" SET "vote_count" = "vote_count" - 1 WHERE "id" = OLD."thread_id";
+    RETURN OLD;
+  END IF;
+  RETURN NULL;
+END $$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS "thread_votes_count_trg" ON "thread_votes";
+CREATE TRIGGER "thread_votes_count_trg"
+  AFTER INSERT OR DELETE ON "thread_votes"
+  FOR EACH ROW EXECUTE FUNCTION "thread_votes_count"();
+
+-- Who hears about a thread, and why. `muted` keeps the row so the reason is
+-- not lost when a person stops listening.
+CREATE TABLE IF NOT EXISTS "thread_subscriptions" (
+  "thread_id" bigint NOT NULL REFERENCES "threads"("id") ON DELETE CASCADE,
+  "person_id" text NOT NULL REFERENCES "thread_people"("id"),
+  "reason" text NOT NULL CHECK ("reason" IN ('author', 'commented', 'voted', 'manual')),
+  "muted" boolean NOT NULL DEFAULT false,
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  PRIMARY KEY ("thread_id", "person_id")
+);
+
+-- Mail to send, never awaited in a request. Claimed with
+-- FOR UPDATE SKIP LOCKED by whatever loop the app runs.
+CREATE TABLE IF NOT EXISTS "thread_outbox" (
+  "id" bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  "person_id" text NOT NULL REFERENCES "thread_people"("id"),
+  "thread_id" bigint NOT NULL REFERENCES "threads"("id") ON DELETE CASCADE,
+  "comment_id" bigint REFERENCES "thread_comments"("id") ON DELETE CASCADE,
+  "kind" text NOT NULL CHECK ("kind" IN ('comment', 'status')),
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "claimed_at" timestamp with time zone,
+  "sent_at" timestamp with time zone,
+  "attempts" integer NOT NULL DEFAULT 0,
+  "last_error" text
+);
+CREATE INDEX IF NOT EXISTS "thread_outbox_pending_idx" ON "thread_outbox" ("created_at") WHERE "sent_at" IS NULL;

package/dist/react/CategoryList.d.ts

@@ -0,0 +1,9 @@
+import type { Category } from '../schema.js';
+export interface CategoryListProps {
+    categories: Category[];
+    basePath: string;
+    /** Thread count per category id, when the page has it. */
+    counts?: Record<string, number>;
+}
+/** The forum's front page: its sections, each a link. */
+export declare function CategoryList({ categories, basePath, counts }: CategoryListProps): import("react").JSX.Element;

package/dist/react/CategoryList.js

@@ -0,0 +1,7 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Empty, Pill, Row, Rows } from '@wtfalch/design';
+/** The forum's front page: its sections, each a link. */
+export function CategoryList({ categories, basePath, counts }) {
+    return (_jsx(Rows, { label: "Categories", empty: _jsx(Empty, { children: "No categories yet." }), children: categories.map((c) => (_jsx(Row, { name: _jsx("a", { className: "threads-link", href: `${basePath}/c/${c.slug}`, children: c.name }), pills: c.kind === 'feedback' ? _jsx(Pill, { inRow: true, children: "Feedback" }) : undefined, hint: c.description ?? undefined, trail: counts && counts[String(c.id)] !== undefined ? (_jsx(Pill, { quiet: true, children: counts[String(c.id)] })) : undefined }, c.id))) }));
+}

package/dist/react/CommentForm.d.ts

@@ -0,0 +1,19 @@
+import type { Outcome } from './format.js';
+export interface CommentFormProps {
+    /** The app's Server Action, or anything that returns an error sentence or nothing. */
+    onSubmit: (body: string) => Promise<Outcome>;
+    label?: string;
+    submitLabel?: string;
+    placeholder?: string;
+    /** Shown beside the submit, for the reply form's "Cancel". */
+    onCancel?: () => void;
+    /** Called after a submit the action did not refuse. */
+    onDone?: () => void;
+    autoFocus?: boolean;
+}
+/**
+ * One textarea and one button, the way every form in the estate is shaped:
+ * `Field` wires the label and the error, the action answers with a sentence
+ * or nothing, and the button is busy rather than disabled while it runs.
+ */
+export declare function CommentForm({ onSubmit, label, submitLabel, placeholder, onCancel, onDone, autoFocus, }: CommentFormProps): import("react").JSX.Element;

package/dist/react/CommentForm.js

@@ -0,0 +1,35 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Callout, Field, Textarea } from '@wtfalch/design';
+import { useState, useTransition } from 'react';
+/**
+ * One textarea and one button, the way every form in the estate is shaped:
+ * `Field` wires the label and the error, the action answers with a sentence
+ * or nothing, and the button is busy rather than disabled while it runs.
+ */
+export function CommentForm({ onSubmit, label = 'Comment', submitLabel = 'Post', placeholder, onCancel, onDone, autoFocus, }) {
+    const [body, setBody] = useState('');
+    const [error, setError] = useState(null);
+    const [pending, start] = useTransition();
+    const submit = () => {
+        const text = body.trim();
+        if (!text) {
+            setError('Write something first.');
+            return;
+        }
+        start(async () => {
+            const result = await onSubmit(text);
+            if (result?.error) {
+                setError(result.error);
+                return;
+            }
+            setBody('');
+            setError(null);
+            onDone?.();
+        });
+    };
+    return (_jsxs("form", { className: "threads-form", onSubmit: (e) => {
+            e.preventDefault();
+            submit();
+        }, children: [_jsx(Field, { label: label, error: error, labelHidden: true, children: (f) => (_jsx(Textarea, { ...f, name: "body", rows: 4, value: body, placeholder: placeholder ?? 'Markdown is fine.', onChange: (e) => setBody(e.target.value), autoFocus: autoFocus, disabled: pending })) }), _jsxs("div", { className: "threads-form-actions", children: [onCancel && (_jsx(Button, { kind: "ghost", size: "sm", onPress: onCancel, disabled: pending, children: "Cancel" })), _jsx(Button, { type: "submit", kind: "primary", size: "sm", busy: pending, disabled: pending, children: submitLabel })] }), error && !pending && body.trim() === '' ? null : null, error && _jsx(Callout, { tone: "bad", children: error })] }));
+}

package/dist/react/CommentSection.d.ts

@@ -0,0 +1,42 @@
+import type { Who } from '../gates.js';
+import type { CommentRow } from '../threads.js';
+import { type Outcome } from './format.js';
+export interface CommentSectionProps {
+    /** Every comment of the thread (or of the subtree), as `comments()` returns them. */
+    comments: CommentRow[];
+    who: Who | null;
+    /** The host's write gate, already asked. */
+    canWrite: boolean;
+    /** The host's moderate gate, already asked. Shows hide/unhide. */
+    canModerate?: boolean;
+    /** The thread is locked: no forms, and a line saying so. */
+    locked?: boolean;
+    /** Build the tree under this comment only, with it at depth 0. */
+    root?: number;
+    /** Fold below this depth. Eight is the reference; 0 renders flat; Infinity never folds. */
+    collapseAt?: number;
+    /** Where "N more replies" goes: `${continueBase}/${commentId}`. Omit to fold without a link. */
+    continueBase?: string;
+    /** Where "sign in to comment" goes, for a reader with no session. */
+    signInHref?: string;
+    onComment: (input: {
+        body: string;
+        replyTo: number | null;
+    }) => Promise<Outcome>;
+    onHideComment?: (input: {
+        id: number;
+        hidden: boolean;
+    }) => Promise<Outcome>;
+    /** What to say when there is nothing yet. */
+    emptyText?: string;
+}
+/**
+ * The discussion under a post, as a tree of any depth.
+ *
+ * Rows come in ordered by `path`, so the tree is one pass; past `collapseAt`
+ * a node keeps its place and its children become a count and a link, which
+ * is Reddit's answer to a thread deeper than a page can indent. A hidden
+ * comment keeps its place too and loses its words, so replies to it still
+ * make sense.
+ */
+export declare function CommentSection({ comments, who, canWrite, canModerate, locked, root, collapseAt, continueBase, signInHref, onComment, onHideComment, emptyText, }: CommentSectionProps): import("react").JSX.Element;

package/dist/react/CommentSection.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Empty, Markdown } from '@wtfalch/design';
+import { useState } from 'react';
+import { buildTree, collapse } from '../tree.js';
+import { CommentForm } from './CommentForm.js';
+import { ago, plural } from './format.js';
+/**
+ * The discussion under a post, as a tree of any depth.
+ *
+ * Rows come in ordered by `path`, so the tree is one pass; past `collapseAt`
+ * a node keeps its place and its children become a count and a link, which
+ * is Reddit's answer to a thread deeper than a page can indent. A hidden
+ * comment keeps its place too and loses its words, so replies to it still
+ * make sense.
+ */
+export function CommentSection({ comments, who, canWrite, canModerate = false, locked = false, root, collapseAt = 8, continueBase, signInHref, onComment, onHideComment, emptyText = 'Nothing here yet.', }) {
+    const tree = collapse(buildTree(comments, root === undefined ? {} : { root }), collapseAt);
+    const [replyingTo, setReplyingTo] = useState(null);
+    return (_jsxs("section", { className: "threads-stack", "aria-label": "Comments", children: [tree.length === 0 ? (_jsx(Empty, { children: emptyText })) : (_jsx("div", { className: "threads-comments", children: tree.map((node) => (_jsx(CommentNode, { node: node, who: who, canWrite: canWrite && !locked, canModerate: canModerate, continueBase: continueBase, replyingTo: replyingTo, setReplyingTo: setReplyingTo, onComment: onComment, onHideComment: onHideComment }, node.id))) })), locked ? (_jsx("p", { className: "threads-note", children: "This thread is locked." })) : canWrite ? (_jsx(CommentForm, { label: "Add a comment", submitLabel: "Comment", onSubmit: (body) => onComment({ body, replyTo: null }) })) : who === null && signInHref ? (_jsxs("p", { className: "threads-note", children: [_jsx("a", { href: signInHref, children: "Sign in" }), " to join the discussion."] })) : who === null ? null : (_jsx("p", { className: "threads-note", children: "Verify your email address to join the discussion." }))] }));
+}
+function CommentNode({ node, who, canWrite, canModerate, continueBase, replyingTo, setReplyingTo, onComment, onHideComment, }) {
+    const replying = replyingTo === node.id;
+    const mine = who !== null && who.id === node.authorId;
+    return (_jsxs("article", { className: "threads-comment", "data-depth": node.depth, id: `c${node.id}`, children: [_jsxs("header", { className: "threads-comment-head", children: [_jsx("span", { className: "threads-comment-author", children: node.authorName ?? 'Someone' }), _jsxs("span", { className: "threads-meta", children: [_jsx("a", { href: `#c${node.id}`, children: ago(node.createdAt) }), node.hidden && _jsx("span", { children: "hidden" }), mine && _jsx("span", { children: "you" })] })] }), _jsx("div", { className: "threads-comment-body", children: node.body === null ? (_jsx("p", { className: "threads-comment-hidden", children: "This comment was hidden by a moderator." })) : (_jsx(Markdown, { text: node.body })) }), _jsxs("div", { className: "threads-comment-actions", children: [canWrite && (_jsx(Button, { kind: "ghost", size: "sm", onPress: () => setReplyingTo(replying ? null : node.id), children: "Reply" })), canModerate && onHideComment && (_jsx(Button, { kind: "ghost", size: "sm", onPress: () => void onHideComment({ id: node.id, hidden: !node.hidden }), children: node.hidden ? 'Unhide' : 'Hide' }))] }), replying && (_jsx(CommentForm, { label: "Reply", submitLabel: "Reply", autoFocus: true, onCancel: () => setReplyingTo(null), onDone: () => setReplyingTo(null), onSubmit: (body) => onComment({ body, replyTo: node.id }) })), node.children.length > 0 && (_jsx("div", { className: "threads-children", children: node.children.map((child) => (_jsx(CommentNode, { node: child, who: who, canWrite: canWrite, canModerate: canModerate, continueBase: continueBase, replyingTo: replyingTo, setReplyingTo: setReplyingTo, onComment: onComment, onHideComment: onHideComment }, child.id))) })), node.folded > 0 && (_jsx("p", { className: "threads-fold", children: continueBase ? (_jsxs("a", { href: `${continueBase}/${node.id}`, children: ["Continue this thread (", plural(node.folded, 'more reply', 'more replies'), ")"] })) : (_jsx("span", { className: "threads-note", children: plural(node.folded, 'more reply', 'more replies') })) }))] }));
+}

package/dist/react/NewThreadForm.d.ts

@@ -0,0 +1,18 @@
+import type { Category } from '../schema.js';
+import type { Outcome } from './format.js';
+export interface NewThreadFormProps {
+    categories: Pick<Category, 'id' | 'name' | 'kind'>[];
+    /** Preselected, when the form is opened from inside a category. */
+    categoryId?: number;
+    /** Prefilled, for a deep link like `/forum/new?title=`. */
+    title?: string;
+    /** The app's Server Action. It redirects to the new thread on success. */
+    onPost: (input: {
+        categoryId: number;
+        title: string;
+        body: string;
+    }) => Promise<Outcome>;
+    onCancel?: () => void;
+}
+/** A title, a body, a category. The action validates for real; this only catches the empty case. */
+export declare function NewThreadForm({ categories, categoryId, title: initialTitle, onPost, onCancel, }: NewThreadFormProps): import("react").JSX.Element;

package/dist/react/NewThreadForm.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Callout, Field, Input, Select, Textarea } from '@wtfalch/design';
+import { useState, useTransition } from 'react';
+/** A title, a body, a category. The action validates for real; this only catches the empty case. */
+export function NewThreadForm({ categories, categoryId, title: initialTitle = '', onPost, onCancel, }) {
+    const [categoryValue, setCategory] = useState(String(categoryId ?? categories[0]?.id ?? ''));
+    const [title, setTitle] = useState(initialTitle);
+    const [body, setBody] = useState('');
+    const [error, setError] = useState(null);
+    const [pending, start] = useTransition();
+    const kind = categories.find((c) => String(c.id) === categoryValue)?.kind;
+    return (_jsxs("form", { className: "threads-form", onSubmit: (e) => {
+            e.preventDefault();
+            if (!title.trim() || !body.trim() || !categoryValue) {
+                setError('A title, a body and a category, please.');
+                return;
+            }
+            start(async () => {
+                const r = await onPost({
+                    categoryId: Number(categoryValue),
+                    title: title.trim(),
+                    body: body.trim(),
+                });
+                if (r?.error)
+                    setError(r.error);
+            });
+        }, children: [categories.length > 1 && (_jsx(Field, { label: "Category", children: (f) => (_jsx(Select, { ...f, value: categoryValue, onChange: (e) => setCategory(e.target.value), disabled: pending, block: true, children: categories.map((c) => (_jsx("option", { value: String(c.id), children: c.name }, c.id))) })) })), _jsx(Field, { label: "Title", hint: kind === 'feedback' ? 'One request per thread, so people can vote on it.' : undefined, children: (f) => (_jsx(Input, { ...f, name: "title", value: title, onChange: (e) => setTitle(e.target.value), maxLength: 200, required: true, block: true, disabled: pending })) }), _jsx(Field, { label: "Body", hint: "Markdown is fine.", children: (f) => (_jsx(Textarea, { ...f, name: "body", rows: 8, value: body, onChange: (e) => setBody(e.target.value), required: true, disabled: pending })) }), error && _jsx(Callout, { tone: "bad", children: error }), _jsxs("div", { className: "threads-form-actions", children: [onCancel && (_jsx(Button, { kind: "ghost", onPress: onCancel, disabled: pending, children: "Cancel" })), _jsx(Button, { type: "submit", kind: "primary", busy: pending, disabled: pending, children: pending ? 'Posting…' : 'Post' })] })] }));
+}

package/dist/react/Roadmap.d.ts

@@ -0,0 +1,10 @@
+import type { ThreadStatus } from '../schema.js';
+import type { ThreadRow } from '../threads.js';
+export interface RoadmapProps {
+    groups: Record<ThreadStatus, ThreadRow[]>;
+    basePath: string;
+    /** Statuses to show, in order. Default: planned, in progress, open, done, declined. */
+    statuses?: ThreadStatus[];
+}
+/** Every feedback thread, grouped by where it stands. Empty groups are skipped. */
+export declare function Roadmap({ groups, basePath, statuses }: RoadmapProps): import("react").JSX.Element;