@jini-ai/admin 0.4.2 → 0.4.4

package/dist/comments/react/hooks/CommentsPage.hooks.d.ts

@@ -0,0 +1,9 @@
+import type { CommentsProps } from '../pages/CommentsPage.js';
+export declare function useCommentsPage(props: CommentsProps, _optional?: Record<string, never>): {
+    canRead: boolean;
+    canConfigure: boolean;
+    permissions: readonly string[] | null;
+    error: string | null;
+    t: import("../../messages.en.js").CommentsTranslator;
+};
+//# sourceMappingURL=CommentsPage.hooks.d.ts.map

package/dist/comments/react/hooks/CommentsPage.hooks.js

@@ -0,0 +1,10 @@
+import { hasPermission } from '../../../core/permissions/rules.js';
+import { useWiredComments } from './use-comments.hooks.js';
+export function useCommentsPage(props, _optional = {}) {
+    const usePage = props.useCommentsHook ?? useWiredComments;
+    const state = usePage({});
+    return { ...state,
+        canRead: hasPermission({ permissions: state.permissions ?? [], permission: 'comments.read' }),
+        canConfigure: hasPermission({ permissions: state.permissions ?? [], permission: 'comments.configure' }) };
+}
+//# sourceMappingURL=CommentsPage.hooks.js.map

package/dist/comments/react/hooks/CommentsPorts.hooks.d.ts

@@ -0,0 +1,13 @@
+import type { AdminCommentsPort } from '../../../core/ports/comments.js';
+import type { CommentsEventsPort, CommentsSessionPort } from '../../ports.js';
+import { type CommentsTranslator } from '../../messages.en.js';
+export interface CommentsPorts {
+    readonly commentsApi: AdminCommentsPort;
+    readonly commentsSession: CommentsSessionPort;
+    readonly commentsEvents?: CommentsEventsPort;
+}
+export declare const CommentsPortsContext: import("react").Context<CommentsPorts | null>;
+export declare const CommentsTranslationContext: import("react").Context<CommentsTranslator>;
+export declare function useCommentsPorts(_required?: Record<string, never>, _optional?: Record<string, never>): CommentsPorts;
+export declare function useCommentsTranslation(_required?: Record<string, never>, _optional?: Record<string, never>): CommentsTranslator;
+//# sourceMappingURL=CommentsPorts.hooks.d.ts.map

package/dist/comments/react/hooks/CommentsPorts.hooks.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/create-admin.js';
+import { englishComments } from '../../messages.en.js';
+export const CommentsPortsContext = createContext(null);
+export const CommentsTranslationContext = createContext(englishComments);
+export function useCommentsPorts(_required = {}, _optional = {}) {
+    const ports = useContext(CommentsPortsContext);
+    if (!ports)
+        throw new AdminConfigError({ issues: ['React scope unavailable: comments'] });
+    return ports;
+}
+export function useCommentsTranslation(_required = {}, _optional = {}) {
+    return useContext(CommentsTranslationContext);
+}
+//# sourceMappingURL=CommentsPorts.hooks.js.map

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

@@ -0,0 +1,62 @@
+import { type ChangeEvent } from 'react';
+import type { DataTableColumn } from '../../../react/components/DataTable.js';
+import type { AdminComment, CommentModerationAction, CommentStatus } from '../../../core/ports/comments.js';
+import { type RowActionState } from '../../rules.js';
+import type { CommentsTranslator } from '../../messages.en.js';
+import { type QueueSectionProps } from '../components/QueueSection.js';
+export declare function useQueueSection(props: QueueSectionProps, _optional?: Record<string, never>): {
+    t: CommentsTranslator;
+    purgeBusy: boolean;
+    onCancelPurge: () => void;
+    status: CommentStatus;
+    setStatus: import("react").Dispatch<import("react").SetStateAction<CommentStatus>>;
+    items: readonly AdminComment[] | null;
+    nextCursor: string | null;
+    error: string | null;
+    loadingMore: boolean;
+    loadMore: () => void;
+    stateFor: (id: string) => RowActionState;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => Promise<void>;
+    pendingPurge: AdminComment | null;
+    setPendingPurge: import("react").Dispatch<import("react").SetStateAction<AdminComment | null>>;
+    onPurge: () => Promise<void>;
+};
+export declare function useQueueToolbar({ onStatusChange }: {
+    onStatusChange: (status: CommentStatus) => void;
+}, _optional?: Record<string, never>): {
+    onChange: (event: ChangeEvent<HTMLSelectElement>) => void;
+};
+export declare function useQueueActionsCell(props: {
+    comment: AdminComment;
+    permissions: readonly string[];
+    status: CommentStatus;
+    t: CommentsTranslator;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => void;
+    onRequestPurge: (comment: AdminComment) => void;
+}, _optional?: Record<string, never>): {
+    menuItems: import("../../../react/index.js").RowMenuItem[];
+};
+/** Builds the `DataTable` column descriptors. A plain function rather than a closure declared
+ *  inside `QueueTable`'s body — it doesn't need to be a hook-scoped closure, only the values
+ *  already threaded through its parameters. */
+export declare function queueColumns(props: {
+    permissions: readonly string[];
+    status: CommentStatus;
+    stateFor: (id: string) => RowActionState;
+    t: CommentsTranslator;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => void;
+    onRequestPurge: (comment: AdminComment) => void;
+    handleForRow: (commentId: string) => string;
+}, _optional?: Record<string, never>): DataTableColumn<AdminComment>[];
+export declare function useQueueTable(props: {
+    items: readonly AdminComment[];
+    permissions: readonly string[];
+    status: CommentStatus;
+    stateFor: (id: string) => RowActionState;
+    t: CommentsTranslator;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => void;
+    onRequestPurge: (comment: AdminComment) => void;
+}, _optional?: Record<string, never>): {
+    columns: DataTableColumn<AdminComment>[];
+};
+//# sourceMappingURL=QueueSection.hooks.d.ts.map

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

@@ -0,0 +1,57 @@
+import { createElement } from 'react';
+import { buildAgentListHandles } from '@jini-ai/agentic';
+import { formatTimestamp } from '@jini-ai/ui/panel-kit';
+import { commentRowMenuItems, truncate } from '../../rules.js';
+import { QueueActionsCell } from '../components/QueueSection.js';
+import { useWiredCommentQueue } from './use-comment-queue.hooks.js';
+import { useCommentsTranslation } from './CommentsPorts.hooks.js';
+export function useQueueSection(props, _optional = {}) {
+    const contextT = useCommentsTranslation();
+    const useQueue = props.useCommentQueueHook ?? useWiredCommentQueue;
+    const queue = useQueue({ permissions: props.permissions });
+    return { ...queue, t: props.t ?? contextT,
+        purgeBusy: queue.pendingPurge !== null && queue.stateFor(queue.pendingPurge.id).busy,
+        onCancelPurge: () => queue.setPendingPurge(null) };
+}
+export function useQueueToolbar({ onStatusChange }, _optional = {}) {
+    return { onChange: (event) => onStatusChange(event.target.value) };
+}
+export function useQueueActionsCell(props, _optional = {}) {
+    return { menuItems: commentRowMenuItems({ comment: props.comment,
+            context: { permissions: props.permissions, currentFilterStatus: props.status },
+            handlers: { onModerate: props.onModerate, onRequestPurge: props.onRequestPurge } }, { t: props.t }) };
+}
+/** Builds the `DataTable` column descriptors. A plain function rather than a closure declared
+ *  inside `QueueTable`'s body — it doesn't need to be a hook-scoped closure, only the values
+ *  already threaded through its parameters. */
+export function queueColumns(props, _optional = {}) {
+    return [
+        { key: "author", header: props.t("Author"), cell: (comment) => comment.authorName },
+        { key: "comment", header: props.t("Comment"), cell: (comment) => truncate({ text: comment.bodyText, max: 120 }) },
+        {
+            key: "status",
+            header: props.t("Status"),
+            cell: (comment) => createElement('span', { className: `status status-${comment.status}` }, props.t(comment.status)),
+        },
+        { key: "depth", header: props.t("Depth"), cell: (comment) => comment.depth },
+        { key: "created", header: props.t("Created"), cell: (comment) => formatTimestamp({ iso: comment.createdAt }, { timeZone: "local" }) },
+        {
+            key: "actions",
+            header: props.t("More"),
+            cell: (comment) => createElement(QueueActionsCell, {
+                comment, agentHandleBase: props.handleForRow(comment.id), permissions: props.permissions,
+                status: props.status, rowState: props.stateFor(comment.id), t: props.t,
+                onModerate: props.onModerate, onRequestPurge: props.onRequestPurge,
+            }),
+        },
+    ];
+}
+export function useQueueTable(props, _optional = {}) {
+    // Rows page in over "Load more", so handles are derived fresh each render from whichever rows
+    // are currently on screen — same per-row-id lookup `Database.tsx`'s `TimelineBody` uses, needed
+    // because `DataTable`'s `cell` callback only receives the row, not its index.
+    const rowHandles = buildAgentListHandles({ prefix: "comments-row", ids: props.items.map((comment) => comment.id) });
+    const handleById = new Map(props.items.map((comment, index) => [comment.id, rowHandles[index]]));
+    return { columns: queueColumns({ ...props, handleForRow: commentId => handleById.get(commentId) }) };
+}
+//# sourceMappingURL=QueueSection.hooks.js.map

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

@@ -0,0 +1,12 @@
+import type { FormEvent } from 'react';
+import type { SettingsSectionProps } from '../components/SettingsSection.js';
+export declare function useSettingsSection(props: SettingsSectionProps, _optional?: Record<string, never>): {
+    t: import("../../messages.en.js").CommentsTranslator;
+    onSubmit: (event: FormEvent<HTMLFormElement>) => void;
+    settings: import("../../index.js").CommentsSettings | null;
+    error: string | null;
+    saving: boolean;
+    notice: string | null;
+    save: (form: FormData) => Promise<void>;
+};
+//# sourceMappingURL=SettingsSection.hooks.d.ts.map

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

@@ -0,0 +1,21 @@
+import { useWiredCommentSettings } from './use-comment-settings.hooks.js';
+import { useCommentsTranslation } from './CommentsPorts.hooks.js';
+/**
+ * Resolves the injected hook prop to the real wired hook when a caller passes none. Pulled into its
+ * own function, the same `??`-avoidance idiom `MenuEditor.tsx`'s `orEmpty`/`CollectionEntryEditor
+ * .tsx`'s `resolveCollectionEntryEditorHook` use: `SettingsSection` was already sitting at the 9/9
+ * complexity ceiling, and ESLint's cyclomatic-complexity rule counts a default value or `??` inside
+ * a function's OWN body as one of that function's own branches — a call out to a separately-scoped
+ * resolver does not.
+ */
+function resolveCommentSettingsHook(override) {
+    return override ?? useWiredCommentSettings;
+}
+export function useSettingsSection(props, _optional = {}) {
+    const contextT = useCommentsTranslation();
+    const useSettings = resolveCommentSettingsHook(props.useCommentSettingsHook);
+    const settings = useSettings({ canConfigure: props.canConfigure });
+    return { ...settings, t: props.t ?? contextT,
+        onSubmit: (event) => { event.preventDefault(); void settings.save(new FormData(event.currentTarget)); } };
+}
+//# sourceMappingURL=SettingsSection.hooks.js.map

package/dist/comments/react/hooks/use-comment-queue.hooks.d.ts

@@ -0,0 +1,34 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { AdminComment, AdminCommentsPort, CommentModerationAction, CommentStatus } from '../../../core/ports/comments.js';
+import { type RowActionState } from '../../rules.js';
+import type { CommentsEventsPort } from '../../ports.js';
+import { type CommentsTranslator } from '../../messages.en.js';
+export interface CommentQueueController {
+    status: CommentStatus;
+    setStatus: Dispatch<SetStateAction<CommentStatus>>;
+    items: readonly AdminComment[] | null;
+    nextCursor: string | null;
+    error: string | null;
+    loadingMore: boolean;
+    loadMore: () => void;
+    stateFor: (id: string) => RowActionState;
+    onModerate: (comment: AdminComment, action: CommentModerationAction) => Promise<void>;
+    pendingPurge: AdminComment | null;
+    setPendingPurge: Dispatch<SetStateAction<AdminComment | null>>;
+    onPurge: () => Promise<void>;
+}
+/** Effects attach to injected ports; cursor/row state belongs to the headless controller.
+ * The shared cache guards stale page-one keys. Cursor settlement is guarded separately because
+ * one fixed query key cannot represent an accumulated list of appended pages.
+ */
+export declare function useCommentQueue({ api, permissions }: {
+    api: AdminCommentsPort;
+    permissions?: readonly string[];
+}, { t, events }?: {
+    t?: CommentsTranslator;
+    events?: CommentsEventsPort;
+}): CommentQueueController;
+export declare function useWiredCommentQueue({ permissions }: {
+    permissions: readonly string[];
+}, _optional?: Record<string, never>): CommentQueueController;
+//# sourceMappingURL=use-comment-queue.hooks.d.ts.map

package/dist/comments/react/hooks/use-comment-queue.hooks.js

@@ -0,0 +1,47 @@
+import { useCallback, useEffect } from 'react';
+import { useFetchQuery, useInvalidate } from '@jini-ai/ui/fetch-query';
+import { useController } from '../../../core/react/use-controller.js';
+import { createCommentQueueController } from '../../controllers/comment-queue.controller.js';
+import { KEYS, emptyRowState } from '../../rules.js';
+import { englishComments } from '../../messages.en.js';
+import { useCommentsPorts, useCommentsTranslation } from './CommentsPorts.hooks.js';
+const NO_GRANTS = [];
+/** Effects attach to injected ports; cursor/row state belongs to the headless controller.
+ * The shared cache guards stale page-one keys. Cursor settlement is guarded separately because
+ * one fixed query key cannot represent an accumulated list of appended pages.
+ */
+export function useCommentQueue({ api, permissions = NO_GRANTS }, { t = englishComments, events } = {}) {
+    const invalidate = useInvalidate();
+    const invalidateQueue = useCallback(() => invalidate({ key: KEYS.queueRoot }), [invalidate]);
+    const { controller, snapshot } = useController({
+        create: () => createCommentQueueController({ api, permissions }, { t, onInvalidate: invalidateQueue }),
+        dependencies: [api, invalidateQueue],
+    });
+    useEffect(() => { controller?.configure({ permissions, t }); }, [controller, permissions, t]);
+    const status = snapshot?.status ?? 'pending';
+    const firstPage = useFetchQuery({ key: KEYS.queue(status), fetch: () => api.listCommentsQueue({}, { status }) });
+    useEffect(() => { controller?.settleFirstPage({ page: firstPage.data ?? null, error: firstPage.error, status }); }, [controller, firstPage.data, firstPage.error, status]);
+    // Stable identity avoids resubscribing on every render. The host filters out unrelated
+    // resources. Unmount removes the subscription even if another cache observer remains active.
+    useEffect(() => events?.subscribe({ onRefresh: invalidateQueue }), [events, invalidateQueue]);
+    return {
+        status,
+        setStatus: value => { if (controller)
+            controller.setStatus({ status: typeof value === 'function' ? value(controller.getSnapshot().status) : value }); },
+        items: snapshot?.items ?? null, nextCursor: snapshot?.nextCursor ?? null,
+        error: snapshot?.error ?? null, loadingMore: snapshot?.loadingMore ?? false,
+        loadMore: () => controller?.loadMore({}),
+        stateFor: id => controller?.stateFor({ id }) ?? emptyRowState(),
+        onModerate: async (comment, action) => { await controller?.onModerate({ comment, action }); },
+        pendingPurge: snapshot?.pendingPurge ?? null,
+        setPendingPurge: value => { if (controller)
+            controller.setPendingPurge({ comment: typeof value === 'function' ? value(controller.getSnapshot().pendingPurge) : value }); },
+        onPurge: async () => { await controller?.onPurge({}); },
+    };
+}
+export function useWiredCommentQueue({ permissions }, _optional = {}) {
+    const { commentsApi, commentsEvents } = useCommentsPorts();
+    const t = useCommentsTranslation();
+    return useCommentQueue({ api: commentsApi, permissions }, { t, ...(commentsEvents ? { events: commentsEvents } : {}) });
+}
+//# sourceMappingURL=use-comment-queue.hooks.js.map

package/dist/comments/react/hooks/use-comment-settings.hooks.d.ts

@@ -0,0 +1,22 @@
+import type { AdminCommentsPort, CommentsSettings } from '../../../core/ports/comments.js';
+import { type CommentsTranslator } from '../../messages.en.js';
+export interface CommentSettingsController {
+    settings: CommentsSettings | null;
+    error: string | null;
+    saving: boolean;
+    notice: string | null;
+    save: (form: FormData) => Promise<void>;
+}
+/** No refresh-event subscription: background settings reads cannot re-seed an uncontrolled form.
+ * The cache envelope is retained for observers of the existing KEYS.settings resource.
+ */
+export declare function useCommentSettings({ api, canConfigure }: {
+    api: AdminCommentsPort;
+    canConfigure: boolean;
+}, { t }?: {
+    t?: CommentsTranslator;
+}): CommentSettingsController;
+export declare function useWiredCommentSettings({ canConfigure }: {
+    canConfigure: boolean;
+}, _optional?: Record<string, never>): CommentSettingsController;
+//# sourceMappingURL=use-comment-settings.hooks.d.ts.map

package/dist/comments/react/hooks/use-comment-settings.hooks.js

@@ -0,0 +1,30 @@
+import { useEffect } from 'react';
+import { useFetchQuery, useInvalidate } from '@jini-ai/ui/fetch-query';
+import { useController } from '../../../core/react/use-controller.js';
+import { createCommentSettingsController } from '../../controllers/comment-settings.controller.js';
+import { KEYS } from '../../rules.js';
+import { englishComments } from '../../messages.en.js';
+import { useCommentsPorts, useCommentsTranslation } from './CommentsPorts.hooks.js';
+/** No refresh-event subscription: background settings reads cannot re-seed an uncontrolled form.
+ * The cache envelope is retained for observers of the existing KEYS.settings resource.
+ */
+export function useCommentSettings({ api, canConfigure }, { t = englishComments } = {}) {
+    // AC-10: even GET is comments.configure-gated. Skip the doomed read for a denied principal.
+    const list = useFetchQuery({ key: KEYS.settings, fetch: async () => ({ data: await api.getCommentsSettings({}) }) }, { enabled: canConfigure });
+    const invalidate = useInvalidate();
+    const { controller, snapshot } = useController({
+        create: () => createCommentSettingsController({ api, permissions: canConfigure ? ['comments.configure'] : [] }, { t, onInvalidate: () => invalidate({ key: KEYS.settings }) }),
+        dependencies: [api, invalidate],
+    });
+    useEffect(() => { controller?.configure({ permissions: canConfigure ? ['comments.configure'] : [], t }); }, [controller, canConfigure, t]);
+    useEffect(() => { controller?.settleRead({ settings: list.data?.data ?? null, error: list.error }); }, [controller, list.data, list.error]);
+    return { settings: snapshot?.settings ?? null, error: snapshot?.error ?? null,
+        saving: snapshot?.saving ?? false, notice: snapshot?.notice ?? null,
+        save: async (form) => { await controller?.save({ form }); } };
+}
+export function useWiredCommentSettings({ canConfigure }, _optional = {}) {
+    const { commentsApi } = useCommentsPorts();
+    const t = useCommentsTranslation();
+    return useCommentSettings({ api: commentsApi, canConfigure }, { t });
+}
+//# sourceMappingURL=use-comment-settings.hooks.js.map

package/dist/comments/react/hooks/use-comments.hooks.d.ts

@@ -0,0 +1,15 @@
+import type { CommentsSessionPort } from '../../ports.js';
+import { type CommentsTranslator } from '../../messages.en.js';
+export interface CommentsController {
+    permissions: readonly string[] | null;
+    error: string | null;
+    t: CommentsTranslator;
+}
+/** Shared query cache owns permission I/O; the headless controller owns its visible state. */
+export declare function useComments({ session }: {
+    session: CommentsSessionPort;
+}, { t }?: {
+    t?: CommentsTranslator;
+}): CommentsController;
+export declare function useWiredComments(_required?: Record<string, never>, _optional?: Record<string, never>): CommentsController;
+//# sourceMappingURL=use-comments.hooks.d.ts.map

package/dist/comments/react/hooks/use-comments.hooks.js

@@ -0,0 +1,20 @@
+import { useEffect } from 'react';
+import { useFetchQuery } from '@jini-ai/ui/fetch-query';
+import { useController } from '../../../core/react/use-controller.js';
+import { createCommentsController } from '../../controllers/comments.controller.js';
+import { KEYS } from '../../rules.js';
+import { useCommentsPorts, useCommentsTranslation } from './CommentsPorts.hooks.js';
+import { englishComments } from '../../messages.en.js';
+/** Shared query cache owns permission I/O; the headless controller owns its visible state. */
+export function useComments({ session }, { t = englishComments } = {}) {
+    const list = useFetchQuery({ key: KEYS.permissions, fetch: () => session.me({}) });
+    const { controller, snapshot } = useController({ create: () => createCommentsController({}), dependencies: [session] });
+    useEffect(() => { controller?.settle({ data: list.data ?? null, error: list.error }); }, [controller, list.data, list.error]);
+    return { permissions: snapshot?.permissions ?? null, error: snapshot?.error ?? null, t };
+}
+export function useWiredComments(_required = {}, _optional = {}) {
+    const { commentsSession } = useCommentsPorts();
+    const t = useCommentsTranslation();
+    return useComments({ session: commentsSession }, { t });
+}
+//# sourceMappingURL=use-comments.hooks.js.map