@jini-ai/admin 0.4.2 → 0.4.4

package/dist/comments/controllers/comment-queue.controller.js

@@ -0,0 +1,164 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { hasPermission } from '../../core/permissions/rules.js';
+import { describeApiError } from '../../core/transport/errors.js';
+import { describeModerationError, emptyRowState } from '../rules.js';
+import { englishComments } from '../messages.en.js';
+/** Headless cursor accumulation and per-row actions; page one remains owned by fetch-query.
+ * Permissions are affordances, denied by default. Every server write must reauthorize.
+ * @param required The core API and current session grants.
+ * @param optional Translator and an invalidation callback for every cached status.
+ * @returns An instance-scoped store and actions; dispose makes pending settlements inert.
+ */
+export function createCommentQueueController({ api, permissions = [] }, { t = englishComments, onInvalidate } = {}) {
+    const store = createControllerStore({ initial: {
+            status: 'pending', items: null, nextCursor: null, error: null, loadingMore: false,
+            rowState: {}, pendingPurge: null,
+        } });
+    let firstPage = null;
+    let morePages = [];
+    let firstError = null;
+    let moreError = null;
+    let pageGeneration = 0;
+    let loadingMore = false;
+    // Synchronous checked-then-set lock: React's busy render cannot block two same-tick actions.
+    // Different actions on the same row share this lock; different rows remain independent.
+    const busyRowIds = new Set();
+    function publishPages() {
+        store.set({ patch: {
+                items: firstPage ? [...firstPage.items, ...morePages] : null,
+                error: moreError ?? (firstError ? describeApiError({ e: firstError, fallback: t('failed to load the moderation queue') }) : null),
+            } });
+    }
+    // Accumulated pages belong to the current first page. A status switch or refreshed page one
+    // supersedes an in-flight cursor read AND releases its synchronous lock, avoiding stuck busy.
+    function resetMorePages() {
+        pageGeneration++;
+        loadingMore = false;
+        morePages = [];
+        moreError = null;
+        store.set({ patch: { loadingMore: false } });
+    }
+    function patchRowState(id, patch) {
+        const current = store.getSnapshot().rowState;
+        store.set({ patch: { rowState: { ...current, [id]: { ...emptyRowState(), ...current[id], ...patch } } } });
+    }
+    function reloadAfterAction() {
+        resetMorePages();
+        publishPages();
+        // An action moves a row to another status. Invalidating only the current filter would leave
+        // previously visited status caches stale, so the hook invalidates KEYS.queueRoot.
+        onInvalidate?.();
+    }
+    function stateFor({ id }, _optional = {}) {
+        return store.getSnapshot().rowState[id] ?? emptyRowState();
+    }
+    /** Locale/grant changes update affordances without losing the existing cursor or row state. */
+    function configure({ permissions: nextPermissions, t: nextTranslator }, _optional = {}) {
+        if (store.signal.aborted)
+            return;
+        permissions = nextPermissions;
+        t = nextTranslator;
+        publishPages();
+    }
+    function setStatus({ status }, _optional = {}) {
+        if (store.signal.aborted || status === store.getSnapshot().status)
+            return;
+        resetMorePages();
+        firstPage = null;
+        firstError = null;
+        store.set({ patch: { status, items: null, nextCursor: null, error: null, rowState: {} } });
+    }
+    function settleFirstPage({ page, error, status }, _optional = {}) {
+        if (store.signal.aborted || status !== store.getSnapshot().status)
+            return;
+        // A successful new page drops stale cursor pages. Error-only notifications do not erase
+        // already rendered data or invalidate a current cursor read.
+        if (page !== firstPage) {
+            resetMorePages();
+            firstPage = page;
+            store.set({ patch: { nextCursor: page?.nextCursor ?? null } });
+        }
+        firstError = error;
+        publishPages();
+    }
+    async function loadMore(_required = {}, _optional = {}) {
+        const { nextCursor, status } = store.getSnapshot();
+        if (store.signal.aborted || !nextCursor || loadingMore)
+            return;
+        loadingMore = true;
+        const generation = ++pageGeneration;
+        moreError = null; // A retry clears the prior failure before its request settles.
+        store.set({ patch: { loadingMore: true } });
+        publishPages();
+        try {
+            const page = await api.listCommentsQueue({}, { status, cursor: nextCursor });
+            if (generation !== pageGeneration || store.signal.aborted)
+                return;
+            morePages = [...morePages, ...page.items];
+            store.set({ patch: { nextCursor: page.nextCursor } });
+            publishPages();
+        }
+        catch (e) {
+            if (generation !== pageGeneration || store.signal.aborted)
+                return;
+            moreError = describeApiError({ e, fallback: t('failed to load the moderation queue') });
+            publishPages();
+        }
+        finally {
+            // The reset already released a superseded call's lock; it must not unlock a newer call.
+            if (generation === pageGeneration && !store.signal.aborted) {
+                loadingMore = false;
+                store.set({ patch: { loadingMore: false } });
+            }
+        }
+    }
+    async function onModerate({ comment, action }, _optional = {}) {
+        const permission = action === 'trash' ? 'comments.delete' : 'comments.moderate';
+        if (store.signal.aborted || !hasPermission({ permissions, permission }) || busyRowIds.has(comment.id))
+            return;
+        busyRowIds.add(comment.id);
+        patchRowState(comment.id, { busy: true, error: null });
+        try {
+            await api.moderateComment({ commentId: comment.id, action, expectedVersion: comment.version });
+            if (!store.signal.aborted)
+                reloadAfterAction();
+        }
+        catch (e) {
+            patchRowState(comment.id, { busy: false, error: describeModerationError({ e }, { t }) });
+        }
+        finally {
+            busyRowIds.delete(comment.id);
+        }
+    }
+    function setPendingPurge({ comment }, _optional = {}) {
+        store.set({ patch: { pendingPurge: comment } });
+    }
+    /** Confirmation closes on success and failure. Errors remain on the affected row. */
+    async function onPurge(_required = {}, _optional = {}) {
+        const comment = store.getSnapshot().pendingPurge;
+        if (store.signal.aborted || !comment || !hasPermission({ permissions, permission: 'comments.delete.force' }) || busyRowIds.has(comment.id))
+            return;
+        busyRowIds.add(comment.id);
+        patchRowState(comment.id, { busy: true, error: null });
+        try {
+            await api.purgeComment({ commentId: comment.id });
+            if (!store.signal.aborted)
+                reloadAfterAction();
+        }
+        catch (e) {
+            patchRowState(comment.id, { busy: false, error: describeApiError({ e, fallback: t('Failed to purge comment.') }) });
+        }
+        finally {
+            busyRowIds.delete(comment.id);
+            setPendingPurge({ comment: null });
+        }
+    }
+    function dispose(_required = {}, _optional = {}) {
+        pageGeneration++;
+        busyRowIds.clear();
+        store.dispose();
+    }
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose, stateFor,
+        configure, setStatus, settleFirstPage, loadMore, onModerate, setPendingPurge, onPurge };
+}
+//# sourceMappingURL=comment-queue.controller.js.map

package/dist/comments/controllers/comment-settings.controller.d.ts

@@ -0,0 +1,32 @@
+import type { AdminCommentsPort, CommentsSettings } from '../../core/ports/comments.js';
+import type { CommentSettingsState } from '../models.js';
+import { type CommentsTranslator } from '../messages.en.js';
+/** Own the uncontrolled form's diff baseline, validation and server-confirmed save.
+ * The query cache owns reads; the FIRST successful read seeds the baseline once.
+ * @returns An instance store with seed/save operations; action grants default denied.
+ */
+export declare function createCommentSettingsController({ api, permissions }: {
+    api: AdminCommentsPort;
+    permissions?: readonly string[];
+}, { t, onInvalidate }?: {
+    t?: CommentsTranslator;
+    onInvalidate?: () => void;
+}): {
+    getSnapshot: () => Readonly<CommentSettingsState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    configure: ({ permissions: nextPermissions, t: nextTranslator }: {
+        permissions: readonly string[];
+        t: CommentsTranslator;
+    }, _optional?: Record<string, never>) => void;
+    settleRead: ({ settings, error }: {
+        settings: CommentsSettings | null;
+        error: Error | null;
+    }, _optional?: Record<string, never>) => void;
+    save: ({ form }: {
+        form: FormData;
+    }, _optional?: Record<string, never>) => Promise<void>;
+};
+//# sourceMappingURL=comment-settings.controller.d.ts.map

package/dist/comments/controllers/comment-settings.controller.js

@@ -0,0 +1,77 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { hasPermission } from '../../core/permissions/rules.js';
+import { buildSettingsPatch, validateSettingsPatch, visibleCommentSettingsError } from '../rules.js';
+import { englishComments } from '../messages.en.js';
+/** Own the uncontrolled form's diff baseline, validation and server-confirmed save.
+ * The query cache owns reads; the FIRST successful read seeds the baseline once.
+ * @returns An instance store with seed/save operations; action grants default denied.
+ */
+export function createCommentSettingsController({ api, permissions = [] }, { t = englishComments, onInvalidate } = {}) {
+    const store = createControllerStore({ initial: { settings: null, error: null, saving: false, notice: null } });
+    let canConfigure = hasPermission({ permissions, permission: 'comments.configure' });
+    let seeded = false;
+    let listError = null;
+    let saveError = null;
+    let validationError = null;
+    function publishError() {
+        store.set({ patch: { error: visibleCommentSettingsError({ validationError, saveError,
+                    saveFallback: t('failed to save Comments settings'), listError,
+                    listFallback: t('failed to load Comments settings'), hasSettings: store.getSnapshot().settings !== null }) } });
+    }
+    /** Update grants/copy while preserving the one-shot uncontrolled-form baseline. */
+    function configure({ permissions: nextPermissions, t: nextTranslator }, _optional = {}) {
+        if (store.signal.aborted)
+            return;
+        canConfigure = hasPermission({ permissions: nextPermissions, permission: 'comments.configure' });
+        t = nextTranslator;
+        publishError();
+    }
+    function settleRead({ settings, error }, _optional = {}) {
+        if (!canConfigure || store.signal.aborted)
+            return;
+        // TM-2026-08-12-A: changing defaultValue/defaultChecked does not change an already mounted
+        // uncontrolled input. Reseeding its diff baseline on a background refetch would quietly
+        // revert another operator's committed field on the next unrelated save. Only this operator's
+        // own save may advance it. Accepted trade: the view stays stale until reload; controlled
+        // drafts and server compare-and-swap were considered and deliberately deferred.
+        if (settings && !seeded) {
+            seeded = true;
+            store.set({ patch: { settings } });
+        }
+        listError = error;
+        publishError();
+    }
+    async function save({ form }, _optional = {}) {
+        const settings = store.getSnapshot().settings;
+        if (!canConfigure || !settings || store.signal.aborted)
+            return;
+        store.set({ patch: { notice: null } });
+        const patch = buildSettingsPatch({ form, current: settings });
+        // Validate before sending, matching the backend's spam score bound.
+        validationError = validateSettingsPatch({ patch }, { t });
+        if (validationError) {
+            publishError();
+            return;
+        }
+        saveError = null;
+        store.set({ patch: { saving: true } });
+        publishError();
+        try {
+            const updated = await api.putCommentsSettings({}, patch);
+            if (store.signal.aborted)
+                return;
+            onInvalidate?.();
+            // Read-your-writes must settle immediately; cache invalidation is deliberately not awaited.
+            store.set({ patch: { settings: updated, notice: t('Saved.') } });
+        }
+        catch (e) {
+            saveError = e instanceof Error ? e : new Error(t('failed to save Comments settings'));
+        }
+        finally {
+            store.set({ patch: { saving: false } });
+            publishError();
+        }
+    }
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose, configure, settleRead, save };
+}
+//# sourceMappingURL=comment-settings.controller.js.map

package/dist/comments/controllers/comments.controller.d.ts

@@ -0,0 +1,16 @@
+import type { CommentsState } from '../models.js';
+/** Permissions settle from the shared query cache; absent grants default to denied. */
+export declare function createCommentsController(_required: Record<string, never>, _optional?: Record<string, never>): {
+    getSnapshot: () => Readonly<CommentsState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    dispose: () => void;
+    settle({ data, error }: {
+        data: {
+            effectivePermissions?: readonly string[];
+        } | null;
+        error: Error | null;
+    }, _options?: Record<string, never>): void;
+};
+//# sourceMappingURL=comments.controller.d.ts.map

package/dist/comments/controllers/comments.controller.js

@@ -0,0 +1,16 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { describeApiError } from '../../core/transport/errors.js';
+/** Permissions settle from the shared query cache; absent grants default to denied. */
+export function createCommentsController(_required, _optional = {}) {
+    const store = createControllerStore({ initial: { permissions: null, error: null } });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, dispose: store.dispose,
+        settle({ data, error }, _options = {}) {
+            store.set({ patch: {
+                    permissions: data ? [...(data.effectivePermissions ?? [])] : null,
+                    error: error ? describeApiError({ e: error, fallback: 'failed to load permissions' }) : null,
+                } });
+        },
+    };
+}
+//# sourceMappingURL=comments.controller.js.map

package/dist/comments/index.d.ts

@@ -0,0 +1,13 @@
+export { commentsModule } from './comments.module.js';
+export { commentsApiToken, commentsSessionToken, commentsEventsToken } from './ports.js';
+export type { CommentsSessionPort, CommentsEventsPort } from './ports.js';
+export type { AdminComment, AdminCommentsPort, AdminCommentsQueuePage, CommentsSettings, CommentModerationAction, CommentStatus } from '../core/ports/comments.js';
+export type { CommentsState, CommentQueueState, CommentSettingsState } from './models.js';
+export { commentsMessagesEn, englishComments } from './messages.en.js';
+export type { CommentsTranslator } from './messages.en.js';
+export { createCommentsController } from './controllers/comments.controller.js';
+export { createCommentQueueController } from './controllers/comment-queue.controller.js';
+export { createCommentSettingsController } from './controllers/comment-settings.controller.js';
+export { KEYS, COMMENTS_QUEUE_RESOURCE, buildSettingsPatch, commentRowMenuItems, describeModerationError, emptyRowState, parseCloseAfterDays, parseOptionalNumber, truncate, validateSettingsPatch, visibleCommentSettingsError } from './rules.js';
+export type { RowActionState, CommentRowMenuHandlers } from './rules.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/comments/index.js

@@ -0,0 +1,8 @@
+export { commentsModule } from './comments.module.js';
+export { commentsApiToken, commentsSessionToken, commentsEventsToken } from './ports.js';
+export { commentsMessagesEn, englishComments } from './messages.en.js';
+export { createCommentsController } from './controllers/comments.controller.js';
+export { createCommentQueueController } from './controllers/comment-queue.controller.js';
+export { createCommentSettingsController } from './controllers/comment-settings.controller.js';
+export { KEYS, COMMENTS_QUEUE_RESOURCE, buildSettingsPatch, commentRowMenuItems, describeModerationError, emptyRowState, parseCloseAfterDays, parseOptionalNumber, truncate, validateSettingsPatch, visibleCommentSettingsError } from './rules.js';
+//# sourceMappingURL=index.js.map

package/dist/comments/messages.en.d.ts

@@ -0,0 +1,54 @@
+/** English source keys stay byte-identical to the host dictionaries. */
+export declare const commentsMessagesEn: {
+    readonly Status: "Status";
+    readonly "Actions for the comment by \"{author}\"": "Actions for the comment by \"{author}\"";
+    readonly Author: "Author";
+    readonly Comment: "Comment";
+    readonly Depth: "Depth";
+    readonly Created: "Created";
+    readonly More: "More";
+    readonly "Loading\u2026": "Loading…";
+    readonly "Load more": "Load more";
+    readonly "Loading comments\u2026": "Loading comments…";
+    readonly "No {status} comments.": "No {status} comments.";
+    readonly "Permanently delete this comment?": "Permanently delete this comment?";
+    readonly "Permanently delete this comment by \"{author}\"? This cannot be undone.": "Permanently delete this comment by \"{author}\"? This cannot be undone.";
+    readonly "Permanently delete": "Permanently delete";
+    readonly "Loading Comments settings\u2026": "Loading Comments settings…";
+    readonly Settings: "Settings";
+    readonly "Comments enabled": "Comments enabled";
+    readonly "Require moderation (new comments start pending)": "Require moderation (new comments start pending)";
+    readonly "Max thread depth": "Max thread depth";
+    readonly "Close submissions after (days, blank = never)": "Close submissions after (days, blank = never)";
+    readonly "Spam auto-reject score (0\u20131)": "Spam auto-reject score (0–1)";
+    readonly "Max submissions per IP per hour": "Max submissions per IP per hour";
+    readonly "Saving\u2026": "Saving…";
+    readonly "Save settings": "Save settings";
+    readonly "Loading Comments\u2026": "Loading Comments…";
+    readonly People: "People";
+    readonly Comments: "Comments";
+    readonly "Moderate incoming comments and configure workspace-wide comment behavior.": "Moderate incoming comments and configure workspace-wide comment behavior.";
+    readonly "You do not have permission to view the moderation queue.": "You do not have permission to view the moderation queue.";
+    readonly "This comment changed since you loaded it (current version {currentVersion}) \u2014 refresh and try again.": "This comment changed since you loaded it (current version {currentVersion}) — refresh and try again.";
+    readonly "This comment changed since you loaded it \u2014 refresh and try again.": "This comment changed since you loaded it — refresh and try again.";
+    readonly "Failed to update comment.": "Failed to update comment.";
+    readonly Approve: "Approve";
+    readonly Spam: "Spam";
+    readonly Trash: "Trash";
+    readonly Restore: "Restore";
+    readonly Purge: "Purge";
+    readonly "Spam auto-reject score must be between 0 and 1.": "Spam auto-reject score must be between 0 and 1.";
+    readonly "failed to load the moderation queue": "failed to load the moderation queue";
+    readonly "Failed to purge comment.": "Failed to purge comment.";
+    readonly "Saved.": "Saved.";
+    readonly "failed to save Comments settings": "failed to save Comments settings";
+    readonly "failed to load Comments settings": "failed to load Comments settings";
+    readonly pending: "Pending";
+    readonly approved: "Approved";
+    readonly spam: "Spam";
+    readonly trash: "Trash";
+};
+export type CommentsTranslator = (key: string, vars?: Record<string, string | number>) => string;
+/** Default copy; unknown keys remain visible and variables use the native string formatter. */
+export declare const englishComments: CommentsTranslator;
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/comments/messages.en.js

@@ -0,0 +1,56 @@
+/** English source keys stay byte-identical to the host dictionaries. */
+export const commentsMessagesEn = {
+    "Status": "Status",
+    "Actions for the comment by \"{author}\"": "Actions for the comment by \"{author}\"",
+    "Author": "Author",
+    "Comment": "Comment",
+    "Depth": "Depth",
+    "Created": "Created",
+    "More": "More",
+    "Loading…": "Loading…",
+    "Load more": "Load more",
+    "Loading comments…": "Loading comments…",
+    "No {status} comments.": "No {status} comments.",
+    "Permanently delete this comment?": "Permanently delete this comment?",
+    "Permanently delete this comment by \"{author}\"? This cannot be undone.": "Permanently delete this comment by \"{author}\"? This cannot be undone.",
+    "Permanently delete": "Permanently delete",
+    "Loading Comments settings…": "Loading Comments settings…",
+    "Settings": "Settings",
+    "Comments enabled": "Comments enabled",
+    "Require moderation (new comments start pending)": "Require moderation (new comments start pending)",
+    "Max thread depth": "Max thread depth",
+    "Close submissions after (days, blank = never)": "Close submissions after (days, blank = never)",
+    "Spam auto-reject score (0–1)": "Spam auto-reject score (0–1)",
+    "Max submissions per IP per hour": "Max submissions per IP per hour",
+    "Saving…": "Saving…",
+    "Save settings": "Save settings",
+    "Loading Comments…": "Loading Comments…",
+    "People": "People",
+    "Comments": "Comments",
+    "Moderate incoming comments and configure workspace-wide comment behavior.": "Moderate incoming comments and configure workspace-wide comment behavior.",
+    "You do not have permission to view the moderation queue.": "You do not have permission to view the moderation queue.",
+    "This comment changed since you loaded it (current version {currentVersion}) — refresh and try again.": "This comment changed since you loaded it (current version {currentVersion}) — refresh and try again.",
+    "This comment changed since you loaded it — refresh and try again.": "This comment changed since you loaded it — refresh and try again.",
+    "Failed to update comment.": "Failed to update comment.",
+    "Approve": "Approve",
+    "Spam": "Spam",
+    "Trash": "Trash",
+    "Restore": "Restore",
+    "Purge": "Purge",
+    "Spam auto-reject score must be between 0 and 1.": "Spam auto-reject score must be between 0 and 1.",
+    "failed to load the moderation queue": "failed to load the moderation queue",
+    "Failed to purge comment.": "Failed to purge comment.",
+    "Saved.": "Saved.",
+    "failed to save Comments settings": "failed to save Comments settings",
+    "failed to load Comments settings": "failed to load Comments settings",
+    "pending": "Pending",
+    "approved": "Approved",
+    "spam": "Spam",
+    "trash": "Trash"
+};
+/** Default copy; unknown keys remain visible and variables use the native string formatter. */
+export const englishComments = (key, vars = {}) => {
+    const template = Object.hasOwn(commentsMessagesEn, key) ? commentsMessagesEn[key] : key;
+    return template.replace(/\{(\w+)\}/g, (placeholder, name) => vars[name] === undefined ? placeholder : String(vars[name]));
+};
+//# sourceMappingURL=messages.en.js.map

package/dist/comments/models.d.ts

@@ -0,0 +1,22 @@
+import type { AdminComment, CommentsSettings, CommentStatus } from '../core/ports/comments.js';
+import type { RowActionState } from './rules.js';
+export interface CommentsState {
+    readonly permissions: readonly string[] | null;
+    readonly error: string | null;
+}
+export interface CommentQueueState {
+    readonly status: CommentStatus;
+    readonly items: readonly AdminComment[] | null;
+    readonly nextCursor: string | null;
+    readonly error: string | null;
+    readonly loadingMore: boolean;
+    readonly rowState: Readonly<Record<string, RowActionState>>;
+    readonly pendingPurge: AdminComment | null;
+}
+export interface CommentSettingsState {
+    readonly settings: CommentsSettings | null;
+    readonly error: string | null;
+    readonly saving: boolean;
+    readonly notice: string | null;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/comments/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/comments/ports.d.ts

@@ -0,0 +1,14 @@
+import type { AdminCommentsPort } from '../core/ports/comments.js';
+import type { AdminAuthPort } from '../core/ports/auth.js';
+/** Session reads reuse the auth owner; no comments-specific permission endpoint exists. */
+export type CommentsSessionPort = Pick<AdminAuthPort, 'me'>;
+/** The host filters notifications to the moderation queue. Settings intentionally never subscribe. */
+export interface CommentsEventsPort {
+    subscribe(required: {
+        onRefresh: () => void;
+    }, optional?: Record<string, never>): () => void;
+}
+export declare const commentsApiToken: import("../core/module/token.js").AdminPortToken<AdminCommentsPort, "admin.comments.api">;
+export declare const commentsSessionToken: import("../core/module/token.js").AdminPortToken<CommentsSessionPort, "admin.comments.session">;
+export declare const commentsEventsToken: import("../core/module/token.js").AdminPortToken<CommentsEventsPort, "admin.comments.events">;
+//# sourceMappingURL=ports.d.ts.map

package/dist/comments/ports.js

@@ -0,0 +1,5 @@
+import { adminPort } from '../core/module/token.js';
+export const commentsApiToken = adminPort({ id: 'admin.comments.api' });
+export const commentsSessionToken = adminPort({ id: 'admin.comments.session' });
+export const commentsEventsToken = adminPort({ id: 'admin.comments.events' });
+//# sourceMappingURL=ports.js.map

package/dist/comments/react/components/QueueSection.d.ts

@@ -0,0 +1,30 @@
+import type { AdminComment, CommentModerationAction, CommentStatus } from '../../../core/ports/comments.js';
+import type { CommentsTranslator } from '../../messages.en.js';
+import type { RowActionState } from '../../rules.js';
+import { useWiredCommentQueue } from '../hooks/use-comment-queue.hooks.js';
+/** The moderation-queue table's "More" column — a `RowMenu` built from `commentRowMenuItems`, or
+ *  an em dash when the operator's permissions leave no items, plus this row's own error (if the
+ *  last action against it failed). Top-level rather than an inline `cell` closure so it has its
+ *  own directly-testable scope, per `commentRowMenuItems`'s own risk ranking. */
+export declare function QueueActionsCell(props: {
+    comment: AdminComment;
+    agentHandleBase: string;
+    permissions: readonly string[];
+    status: CommentStatus;
+    rowState: RowActionState;
+    t: CommentsTranslator;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => void;
+    onRequestPurge: (comment: AdminComment) => void;
+}): import("react").JSX.Element;
+export interface QueueSectionProps {
+    permissions: readonly string[];
+    t?: CommentsTranslator;
+    /** Dependency injection seam for tests — the same convention `@jini-ai/ui`'s `CustomSelect` uses
+     *  for `useCustomSelect`. Defaulted to the real hook, so production callers (the exported
+     *  `Comments` below) pass nothing and behave exactly as before. */
+    useCommentQueueHook?: typeof useWiredCommentQueue;
+}
+/** Exported (2026-08-14, previously module-private) so `QueueSection.unit.test.tsx` can drive its
+ *  own DI seam directly — the same reason `AiAssistant.tsx`'s `AdminExecutionMode` is exported. */
+export declare function QueueSection(props: QueueSectionProps): import("react").JSX.Element;
+//# sourceMappingURL=QueueSection.d.ts.map

package/dist/comments/react/components/QueueSection.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DataTable } from '../../../react/components/DataTable.js';
+import { RowMenu } from '../../../react/components/RowMenu/RowMenu.js';
+import { ConfirmDialog } from '../../../react/components/ConfirmDialog/ConfirmDialog.js';
+import { agentHandle } from '@jini-ai/agentic';
+import { interpolate } from '@jini-ai/ui/panel-kit';
+import { useWiredCommentQueue } from '../hooks/use-comment-queue.hooks.js';
+import { useQueueSection, useQueueActionsCell, useQueueTable, useQueueToolbar } from '../hooks/QueueSection.hooks.js';
+const STATUS_OPTIONS = ["pending", "approved", "spam", "trash"];
+/** The status-filter `<select>` — pure presentation, no state of its own. */
+function QueueToolbar({ status, onStatusChange, t, }) {
+    const { onChange } = useQueueToolbar({ onStatusChange });
+    return (_jsx("div", { className: "toolbar", children: _jsxs("div", { className: "field", children: [_jsx("label", { className: "field-label", htmlFor: "comments-status-filter", children: t("Status") }), _jsx("select", { id: "comments-status-filter", value: status, onChange: onChange, ...agentHandle({ handle: "comments-status-filter" }, { role: "field", label: "Filter the moderation queue by status" }), children: STATUS_OPTIONS.map((s) => (_jsx("option", { value: s, children: t(s) }, s))) })] }) }));
+}
+/** The moderation-queue table's "More" column — a `RowMenu` built from `commentRowMenuItems`, or
+ *  an em dash when the operator's permissions leave no items, plus this row's own error (if the
+ *  last action against it failed). Top-level rather than an inline `cell` closure so it has its
+ *  own directly-testable scope, per `commentRowMenuItems`'s own risk ranking. */
+export function QueueActionsCell(props) {
+    const { menuItems } = useQueueActionsCell(props);
+    return (_jsxs(_Fragment, { children: [menuItems.length > 0 ? (_jsx(RowMenu, { triggerLabel: interpolate({ template: props.t('Actions for the comment by "{author}"'), vars: {
+                        author: props.comment.authorName,
+                    } }), agentHandle: `${props.agentHandleBase}-menu`, items: menuItems })) : (_jsx("span", { className: "muted-cell", children: "\u2014" })), props.rowState.error ? (_jsx("div", { className: "notice error", role: "alert", children: props.rowState.error })) : null] }));
+}
+/** The populated-queue view: the table plus its "Load more" pager. Only rendered once
+ *  `QueueItemsView` has already ruled out the loading/empty states. */
+function QueueTable(props) {
+    const { columns } = useQueueTable(props);
+    return (_jsxs(_Fragment, { children: [_jsx(DataTable, { rows: props.items, rowKey: (comment) => comment.id, columns: columns }), props.nextCursor ? (_jsx("button", { type: "button", className: "btn-secondary", onClick: props.loadMore, disabled: props.loadingMore, ...agentHandle({ handle: "comments-load-more" }, { role: "button", label: "Load more comments" }), children: props.loadingMore ? props.t("Loading…") : props.t("Load more") })) : null] }));
+}
+/** Dispatches between the three queue-body states (loading / empty / populated) as a flat
+ *  if-chain instead of a nested ternary — the nesting was the cognitive-complexity cost in the
+ *  original inline JSX, not the branch count itself. */
+function QueueItemsView(props) {
+    if (!props.items)
+        return _jsx("div", { className: "notice", children: props.t("Loading comments…") });
+    if (props.items.length === 0) {
+        return (_jsx("div", { className: "card", children: _jsx("div", { className: "empty-state", children: _jsx("p", { children: interpolate({ template: props.t("No {status} comments."), vars: { status: props.status } }) }) }) }));
+    }
+    return _jsx(QueueTable, { ...props, items: props.items });
+}
+/** The Purge confirm dialog. Stays mounted unconditionally (driven by `open`) — see
+ *  `useCommentQueue`'s `pendingPurge` doc comment for why. */
+function QueuePurgeDialog(props) {
+    return (_jsx(ConfirmDialog, { open: props.pendingPurge !== null, agentHandle: "comments-purge", title: props.t("Permanently delete this comment?"), body: props.pendingPurge ? (_jsx("p", { children: interpolate({ template: props.t('Permanently delete this comment by "{author}"? This cannot be undone.'), vars: {
+                    author: props.pendingPurge.authorName,
+                } }) })) : null, confirmLabel: props.t("Permanently delete"), destructive: true, pending: props.busy, onConfirm: props.onConfirm, onCancel: props.onCancel }));
+}
+/** Exported (2026-08-14, previously module-private) so `QueueSection.unit.test.tsx` can drive its
+ *  own DI seam directly — the same reason `AiAssistant.tsx`'s `AdminExecutionMode` is exported. */
+export function QueueSection(props) {
+    const { t, status, setStatus, items, nextCursor, error, loadingMore, loadMore, stateFor, onModerate, pendingPurge, setPendingPurge, onPurge, onCancelPurge, purgeBusy, } = useQueueSection(props);
+    if (error && !items)
+        return _jsx("div", { className: "notice error", children: error });
+    return (_jsxs("div", { children: [_jsx(QueueToolbar, { status: status, onStatusChange: setStatus, t: t }), error ? _jsx("div", { className: "notice error", children: error }) : null, _jsx(QueueItemsView, { items: items, status: status, nextCursor: nextCursor, loadingMore: loadingMore, loadMore: loadMore, permissions: props.permissions, stateFor: stateFor, t: t, onModerate: onModerate, onRequestPurge: setPendingPurge }), _jsx(QueuePurgeDialog, { pendingPurge: pendingPurge, busy: purgeBusy, t: t, onConfirm: onPurge, onCancel: onCancelPurge })] }));
+}
+//# sourceMappingURL=QueueSection.js.map

package/dist/comments/react/components/SettingsSection.d.ts

@@ -0,0 +1,14 @@
+import type { CommentsTranslator } from '../../messages.en.js';
+import { useWiredCommentSettings } from '../hooks/use-comment-settings.hooks.js';
+export interface SettingsSectionProps {
+    canConfigure: boolean;
+    t?: CommentsTranslator;
+    /** Dependency injection seam for tests — the same convention `@jini-ai/ui`'s `CustomSelect` uses
+     *  for `useCustomSelect`. Defaulted to the real hook, so production callers (the exported
+     *  `Comments` below) pass nothing and behave exactly as before. */
+    useCommentSettingsHook?: typeof useWiredCommentSettings;
+}
+/** Exported (2026-08-14, previously module-private) so `SettingsSection.unit.test.tsx` can drive
+ *  its own DI seam directly — see `QueueSection`'s identical doc comment above. */
+export declare function SettingsSection(props: SettingsSectionProps): import("react").JSX.Element | null;
+//# sourceMappingURL=SettingsSection.d.ts.map

package/dist/comments/react/components/SettingsSection.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { agentHandle } from '@jini-ai/agentic';
+import { useWiredCommentSettings } from '../hooks/use-comment-settings.hooks.js';
+import { useSettingsSection } from '../hooks/SettingsSection.hooks.js';
+/** Exported (2026-08-14, previously module-private) so `SettingsSection.unit.test.tsx` can drive
+ *  its own DI seam directly — see `QueueSection`'s identical doc comment above. */
+export function SettingsSection(props) {
+    const { settings, error, saving, notice, onSubmit, t } = useSettingsSection(props);
+    if (!props.canConfigure)
+        return null;
+    if (error && !settings)
+        return _jsx("div", { className: "notice error", children: error });
+    if (!settings)
+        return _jsx("div", { className: "notice", children: t("Loading Comments settings…") });
+    return (_jsxs("div", { children: [_jsx("h2", { children: t("Settings") }), error ? _jsx("div", { className: "notice error", children: error }) : null, notice ? _jsx("div", { className: "notice", children: notice }) : null, _jsxs("form", { className: "card", onSubmit: onSubmit, children: [_jsxs("div", { className: "field-group", children: [_jsxs("label", { className: "form-checkbox-field", children: [_jsx("input", { type: "checkbox", name: "enabled", defaultChecked: settings.enabled, ...agentHandle({ handle: "comments-settings-enabled" }, { role: "field", label: "Whether comments are enabled at all" }) }), t("Comments enabled")] }), _jsxs("label", { className: "form-checkbox-field", children: [_jsx("input", { type: "checkbox", name: "requireModeration", defaultChecked: settings.requireModeration, ...agentHandle({ handle: "comments-settings-require-moderation" }, {
+                                            role: "field",
+                                            label: "Whether new comments start pending moderation",
+                                        }) }), t("Require moderation (new comments start pending)")] })] }), _jsx("div", { className: "field-group", children: _jsxs("div", { className: "field-row", children: [_jsxs("div", { className: "field", children: [_jsx("label", { className: "field-label", htmlFor: "comments-max-depth", children: t("Max thread depth") }), _jsx("input", { id: "comments-max-depth", type: "number", name: "maxDepth", min: 0, step: 1, defaultValue: settings.maxDepth, ...agentHandle({ handle: "comments-settings-max-depth" }, { role: "field", label: "Maximum comment thread depth" }) })] }), _jsxs("div", { className: "field", children: [_jsx("label", { className: "field-label", htmlFor: "comments-close-after-days", children: t("Close submissions after (days, blank = never)") }), _jsx("input", { id: "comments-close-after-days", type: "number", name: "closeAfterDays", min: 0, step: 1, defaultValue: settings.closeAfterDays ?? "", ...agentHandle({ handle: "comments-settings-close-after-days" }, {
+                                                role: "field",
+                                                label: "Days after which submissions close, blank for never",
+                                            }) })] }), _jsxs("div", { className: "field", children: [_jsx("label", { className: "field-label", htmlFor: "comments-spam-score", children: t("Spam auto-reject score (0–1)") }), _jsx("input", { id: "comments-spam-score", type: "number", name: "spamAutoRejectScore", min: 0, max: 1, step: 0.01, defaultValue: settings.spamAutoRejectScore, ...agentHandle({ handle: "comments-settings-spam-score" }, { role: "field", label: "Spam auto-reject score, 0 to 1" }) })] }), _jsxs("div", { className: "field", children: [_jsx("label", { className: "field-label", htmlFor: "comments-max-per-ip", children: t("Max submissions per IP per hour") }), _jsx("input", { id: "comments-max-per-ip", type: "number", name: "maxPerIpPerHour", min: 1, step: 1, defaultValue: settings.maxPerIpPerHour, ...agentHandle({ handle: "comments-settings-max-per-ip" }, { role: "field", label: "Maximum submissions per IP per hour" }) })] })] }) }), _jsx("div", { className: "editor-actions form-actions", children: _jsx("button", { type: "submit", disabled: saving, ...agentHandle({ handle: "comments-settings-save" }, { role: "button", label: "Save the comments settings" }), children: saving ? t("Saving…") : t("Save settings") }) })] })] }));
+}
+//# sourceMappingURL=SettingsSection.js.map